webdav.client 5.20.5664

package/Tests/HierarchyItems/NameCheck.js

@@ -0,0 +1,184 @@
+/**
+ * @typedef {ITHit.WebDAV.Client.WebDavSession} webDavSession
+ */
+
+QUnit.module('HierarchyItems.NameCheck');
+
+/**
+ * @class ITHit.WebDAV.Client.Tests.HierarchyItems.NameCheck
+ */
+ITHit.DefineClass('ITHit.WebDAV.Client.Tests.HierarchyItems.NameCheck', null, {}, /** @lends ITHit.WebDAV.Client.Tests.HierarchyItems.NameCheck */{
+
+    CheckFileName: function(test, sSymbol) {
+        QUnit.stop();
+        Helper.Create([
+            'HierarchyItems/NameCheck/'
+        ], function() {
+            QUnit.start();
+
+            QUnit.stop();
+            Helper.GetFolder(Helper.GetPath('HierarchyItems/NameCheck/').substr(1), function(oRootFolder) {
+                QUnit.start();
+
+                var sName = 'sym' + sSymbol + 'bol.txt';
+
+                QUnit.stop();
+                oRootFolder.CreateFileAsync(sName, null, 'my content', null, function(oAsyncResult) {
+                    QUnit.start();
+
+                    test.strictEqual(oAsyncResult.IsSuccess, true, 'Check success of create file with symbol: ' + sSymbol);
+					if (!oAsyncResult.IsSuccess) {
+						return;
+					}
+
+                    /** @typedef {ITHit.WebDAV.Client.File} oFile */
+                    var oFile = oAsyncResult.Result;
+
+                    ITHit.WebDAV.Client.Tests.HierarchyItems.NameCheck._CheckItemName(test, oRootFolder, oFile, sSymbol);
+                });
+            });
+        });
+    },
+
+    CheckFolderName: function(test, sSymbol) {
+        QUnit.stop();
+        Helper.Create([
+            'HierarchyItems/NameCheck/'
+        ], function() {
+            QUnit.start();
+
+            QUnit.stop();
+            Helper.GetFolder(Helper.GetPath('HierarchyItems/NameCheck/').substr(1), function(oRootFolder) {
+                QUnit.start();
+
+                var sName = 'sym' + sSymbol + 'bol';
+
+                QUnit.stop();
+                oRootFolder.CreateFolderAsync(sName, null, null, function(oAsyncResult) {
+                    QUnit.start();
+
+                    test.strictEqual(oAsyncResult.IsSuccess, true, 'Check success of create folder with symbol: ' + sSymbol);
+
+                    /** @typedef {ITHit.WebDAV.Client.Folder} oFolder */
+                    var oFolder = oAsyncResult.Result;
+
+                    ITHit.WebDAV.Client.Tests.HierarchyItems.NameCheck._CheckItemName(test, oRootFolder, oFolder, sSymbol);
+                });
+            });
+        });
+    },
+
+    _CheckItemName: function (test, oRootFolder, oItem, sSymbol) {
+        if (oItem) {
+            QUnit.stop();
+            oItem.CopyToAsync(oRootFolder, 'copy' + oItem.DisplayName, false, false, null, function (oAsyncResult) {
+                QUnit.start();
+
+                test.strictEqual(oAsyncResult.IsSuccess, true, 'Check success of copy request, symbol: ' + sSymbol);
+
+                QUnit.stop();
+                oRootFolder.GetItemAsync('copy' + oItem.DisplayName, function (oAsyncResult) {
+                    QUnit.start();
+
+                    test.strictEqual(oAsyncResult.IsSuccess, true, 'Check success of get copied item request, symbol: ' + sSymbol);
+
+                    /** @typedef {ITHit.WebDAV.Client.Folder} oCopiedItem */
+                    var oCopiedItem = oAsyncResult.Result;
+                    test.strictEqual(oCopiedItem.DisplayName, 'copy' + oItem.DisplayName, 'Check copied item name, symbol: ' + sSymbol);
+                    if (oCopiedItem instanceof ITHit.WebDAV.Client.File) {
+                        test.strictEqual(oCopiedItem.ContentLength, 10, 'Check copied item length, symbol: ' + sSymbol);
+                    }
+
+                    QUnit.stop();
+                    oCopiedItem.MoveToAsync(oRootFolder, 'move' + oItem.DisplayName, true, null, function (oAsyncResult) {
+                        QUnit.start();
+
+                        test.strictEqual(oAsyncResult.IsSuccess, true, 'Check success of move request, symbol: ' + sSymbol);
+
+                        QUnit.stop();
+                        oRootFolder.GetItemAsync('move' + oItem.DisplayName, function (oAsyncResult) {
+                            QUnit.start();
+
+                            test.strictEqual(oAsyncResult.IsSuccess, true, 'Check success of get moved item request, symbol: ' + sSymbol);
+
+                            /** @typedef {ITHit.WebDAV.Client.Folder} oMovedItem */
+                            var oMovedItem = oAsyncResult.Result;
+                            test.strictEqual(oMovedItem.DisplayName, 'move' + oItem.DisplayName, 'Check renamed item name, symbol: ' + sSymbol);
+                            if (oCopiedItem instanceof ITHit.WebDAV.Client.File) {
+                                test.strictEqual(oCopiedItem.ContentLength, 10, 'Check renamed item length, symbol: ' + sSymbol);
+                            }
+
+                            test.strictEqual(oAsyncResult.Result.DisplayName, 'move' + oItem.DisplayName, 'Check renamed item name, symbol: ' + sSymbol);
+                        });
+                    });
+                });
+            });
+        }
+    }
+
+});
+
+// @todo Todo? (moved from old tests): `?*()-_={}[];:'",.|/\<>
+
+QUnitRunner.test('Symbol & in file name', function (test) {
+    ITHit.WebDAV.Client.Tests.HierarchyItems.NameCheck.CheckFileName(test, '&');
+});
+QUnitRunner.test('Symbol # in file name', function (test) {
+    ITHit.WebDAV.Client.Tests.HierarchyItems.NameCheck.CheckFileName(test, '#');
+});
+QUnitRunner.test('Symbol @ in file name', function (test) {
+    ITHit.WebDAV.Client.Tests.HierarchyItems.NameCheck.CheckFileName(test, '@');
+});
+QUnitRunner.test('Symbol ^ in file name', function (test) {
+    ITHit.WebDAV.Client.Tests.HierarchyItems.NameCheck.CheckFileName(test, '^');
+});
+QUnitRunner.test('Symbol ! in file name', function (test) {
+    ITHit.WebDAV.Client.Tests.HierarchyItems.NameCheck.CheckFileName(test, '!');
+});
+QUnitRunner.test('Symbol ~ in file name', function (test) {
+    ITHit.WebDAV.Client.Tests.HierarchyItems.NameCheck.CheckFileName(test, '~');
+});
+QUnitRunner.test('Symbol $ in file name', function (test) {
+    ITHit.WebDAV.Client.Tests.HierarchyItems.NameCheck.CheckFileName(test, '$');
+});
+QUnitRunner.test('Space in file name', function (test) {
+    ITHit.WebDAV.Client.Tests.HierarchyItems.NameCheck.CheckFileName(test, 'a b');
+});
+/*QUnitRunner.test('Symbol % in file', function (test) { // @todo Symbol % is not worked
+    ITHit.WebDAV.Client.Tests.HierarchyItems.NameCheck.CheckFileName(test, '%');
+});*/
+QUnitRunner.test('Symbol + in file name', function (test) {
+    ITHit.WebDAV.Client.Tests.HierarchyItems.NameCheck.CheckFileName(test, '+');
+});
+
+
+QUnitRunner.test('Symbol & in folder name', function (test) {
+    ITHit.WebDAV.Client.Tests.HierarchyItems.NameCheck.CheckFolderName(test, '&');
+});
+QUnitRunner.test('Symbol # in folder name', function (test) {
+    ITHit.WebDAV.Client.Tests.HierarchyItems.NameCheck.CheckFolderName(test, '#');
+});
+QUnitRunner.test('Symbol @ in folder name', function (test) {
+    ITHit.WebDAV.Client.Tests.HierarchyItems.NameCheck.CheckFolderName(test, '@');
+});
+QUnitRunner.test('Symbol ^ in folder name', function (test) {
+    ITHit.WebDAV.Client.Tests.HierarchyItems.NameCheck.CheckFolderName(test, '^');
+});
+QUnitRunner.test('Symbol ! in folder name', function (test) {
+    ITHit.WebDAV.Client.Tests.HierarchyItems.NameCheck.CheckFolderName(test, '!');
+});
+QUnitRunner.test('Symbol ~ in folder name', function (test) {
+    ITHit.WebDAV.Client.Tests.HierarchyItems.NameCheck.CheckFolderName(test, '~');
+});
+QUnitRunner.test('Symbol $ in folder name', function (test) {
+    ITHit.WebDAV.Client.Tests.HierarchyItems.NameCheck.CheckFolderName(test, '$');
+});
+QUnitRunner.test('Space in folder name', function (test) {
+    ITHit.WebDAV.Client.Tests.HierarchyItems.NameCheck.CheckFolderName(test, 'a b');
+});
+/*QUnitRunner.test('Symbol % in folder name', function (test) {
+    ITHit.WebDAV.Client.Tests.HierarchyItems.NameCheck.CheckFolderName(test, '%');
+});*/
+QUnitRunner.test('Symbol + in folder name', function (test) {
+    ITHit.WebDAV.Client.Tests.HierarchyItems.NameCheck.CheckFolderName(test, '+');
+});

package/Tests/HierarchyItems/Progress.js

@@ -0,0 +1,89 @@
+/**
+ * @typedef {ITHit.WebDAV.Client.WebDavSession} webDavSession
+ */
+
+QUnit.module('HierarchyItems.Progress');
+
+/**
+ * @class ITHit.WebDAV.Client.Tests.HierarchyItems.Progress
+ */
+ITHit.DefineClass('ITHit.WebDAV.Client.Tests.HierarchyItems.Progress', null, {}, /** @lends ITHit.WebDAV.Client.Tests.HierarchyItems.Progress */{
+
+    /**
+     * @param {ITHit.WebDAV.Client.WebDavSession} [webDavSession=new ITHit.WebDAV.Client.WebDavSession()]
+     * @param {string} [sFolderAbsolutePath='http://localhost:87654/']
+     * @param {function} [fCallback=function() {}]
+     */
+    Progress: function(webDavSession, sFolderAbsolutePath, fCallback) {
+        webDavSession.OpenFolderAsync(sFolderAbsolutePath, null, function(oAsyncResult) {
+
+            /** @typedef {ITHit.WebDAV.Client.Folder} oFolder */
+            var oFolder = oAsyncResult.Result;
+
+            var oRequest = oFolder.GetChildrenAsync(true, null, function(oAsyncResult) {
+
+                if (oAsyncResult.IsSuccess) {
+                    console.log('Count of children: ' + oAsyncResult.Result.length);
+                }
+
+            });
+
+            // Subscribe on progress event
+            oRequest.AddListener('OnProgress', function(oEvent) {
+                /** @typedef {ITHit.WebDAV.Client.RequestProgress} oProgress */
+                var oProgress = oEvent.Progress;
+
+                var aOfText = oProgress.LengthComputable ?
+                    [oProgress.BytesLoaded, 'of', oProgress.BytesTotal, 'bytes'] :
+                    [oProgress.CountComplete, 'of', oProgress.CountTotal];
+
+                console.log('Progress: ' + oProgress.Percent + '% (' + aOfText.join(' ') + ')');
+            });
+
+            fCallback(oRequest);
+        });
+    }
+
+});
+
+QUnitRunner.test('Subscribe on progress event and get progress info', function (test) {
+    if (ITHit.DetectBrowser.IE && ITHit.DetectBrowser.IE <= 9) {
+        ITHitTests.skip(test, 'Internet Explorer 9 and lower versions does not support `onprogress` event.');
+        return;
+    }
+
+    QUnit.stop();
+    Helper.Create([
+        'HierarchyItems/Progress/item1.txt',
+        'HierarchyItems/Progress/item2.txt',
+        'HierarchyItems/Progress/item3.txt',
+        'HierarchyItems/Progress/item4.txt',
+        'HierarchyItems/Progress/item5.txt',
+        'HierarchyItems/Progress/item6.txt',
+        'HierarchyItems/Progress/item7.txt',
+        'HierarchyItems/Progress/item8.txt',
+        'HierarchyItems/Progress/item9.txt'
+    ], function() {
+        QUnit.start();
+
+        QUnit.stop();
+        ITHit.WebDAV.Client.Tests.HierarchyItems.Progress.Progress(webDavSession, Helper.GetAbsolutePath('HierarchyItems/Progress/'), function(oRequest) {
+            var aProgresses = [];
+
+            oRequest.AddListener('OnProgress', function(oEvent) {
+                aProgresses.push(oEvent.Progress);
+            });
+
+            oRequest.AddListener('OnFinish', function() {
+                QUnit.start();
+
+                test.strictEqual(oRequest.Progress.Percent, 100, 'Check progress percent is 100 of request link');
+                test.strictEqual(aProgresses.length >= 1, true, 'Check count events >= 1');
+
+                var oLastProgress = aProgresses[aProgresses.length - 1];
+                test.strictEqual(oLastProgress instanceof ITHit.WebDAV.Client.RequestProgress, true, 'Check last progress is instance of RequestProgress');
+                test.strictEqual(oLastProgress.Percent, 100, 'Check progress percent is 100 of last RequestProgress instance');
+            });
+        });
+    });
+});

package/Tests/HierarchyItems/Quota.js

@@ -0,0 +1,35 @@
+/**
+ * @typedef {ITHit.WebDAV.Client.WebDavSession} webDavSession
+ */
+
+QUnit.module('HierarchyItems.Quota');
+
+QUnitRunner.test('Check quota properties available', function (test) {
+    QUnit.stop();
+    Helper.Create([
+        'HierarchyItems/Quota/'
+    ], function() {
+        QUnit.start();
+
+        QUnit.stop();
+        webDavSession.OpenFolderAsync(Helper.GetAbsolutePath('HierarchyItems/Quota/'), null, function(oAsyncResult) {
+            QUnit.start();
+
+            test.strictEqual(oAsyncResult.IsSuccess, true, 'Check success of open folder request');
+
+            /** @typedef {ITHit.WebDAV.Client.Folder} oFolder */
+            var oFolder = oAsyncResult.Result;
+
+            if (oFolder.AvailableBytes === -1 && oFolder.UsedBytes === -1) {
+                ITHitTests.skip(test, 'Server does not have quota information.');
+                return;
+            }
+
+            test.strictEqual(typeof oFolder.AvailableBytes, 'number', 'Check type of property AvailableBytes');
+            test.strictEqual(typeof oFolder.UsedBytes, 'number', 'Check type of property UsedBytes');
+
+            test.ok(oFolder.AvailableBytes >= 0, 'Check AvailableBytes more or equal than zero');
+            test.ok(oFolder.UsedBytes >= 0, 'Check UsedBytes more or equal than zero');
+        });
+    });
+});

package/Tests/HierarchyItems/Refresh.js

@@ -0,0 +1,68 @@
+/**
+ * @typedef {ITHit.WebDAV.Client.WebDavSession} webDavSession
+ */
+
+QUnit.module('HierarchyItems.Refresh');
+
+/**
+ * @class ITHit.WebDAV.Client.Tests.HierarchyItems.Refresh
+ */
+ITHit.DefineClass('ITHit.WebDAV.Client.Tests.HierarchyItems.Refresh', null, {}, /** @lends ITHit.WebDAV.Client.Tests.HierarchyItems.Refresh */{
+
+    /**
+     * @param {ITHit.WebDAV.Client.WebDavSession} [webDavSession=new ITHit.WebDAV.Client.WebDavSession()]
+     * @param {string} [sFileAbsolutePath='http://localhost:87654/myfile.txt']
+     * @param {function} [fCallback=function() {}]
+     */
+    Refresh: function(webDavSession, sFileAbsolutePath, fCallback) {
+        webDavSession.OpenFileAsync(sFileAbsolutePath, null, function(oFileAsyncResult) {
+
+            /** @typedef {ITHit.WebDAV.Client.File} oFile */
+            var oFile = oFileAsyncResult.Result;
+
+            // Return file content length
+            console.log('Content length: ' + oFile.ContentLength);
+
+            // Update file content
+            oFile.WriteContentAsync('My updated content', null, null, function() {
+
+                // Refresh item from server to read new content length
+                oFile.RefreshAsync(function(oAsyncResult) {
+
+                    // Return file content length
+                    console.log('Content length: ' + oFile.ContentLength);
+
+                    fCallback(oAsyncResult, oFile);
+                });
+            });
+        });
+    }
+
+});
+
+QUnitRunner.test('Refresh item', function (test) {
+    QUnit.stop();
+    Helper.Create([
+        'HierarchyItems/Refresh/myfile.txt'
+    ], function() {
+        QUnit.start();
+
+        QUnit.stop();
+        webDavSession.OpenFileAsync(Helper.GetAbsolutePath('HierarchyItems/Refresh/myfile.txt'), null, function(oAsyncResult) {
+            QUnit.start();
+
+            /** @typedef {ITHit.WebDAV.Client.File} oFile */
+            var oFile = oAsyncResult.Result;
+
+            test.strictEqual(oFile.ContentLength, 6, 'Check file content length');
+
+            QUnit.stop();
+            ITHit.WebDAV.Client.Tests.HierarchyItems.Refresh.Refresh(webDavSession, Helper.GetAbsolutePath('HierarchyItems/Refresh/myfile.txt'), function(oAsyncResult, oFile) {
+                QUnit.start();
+
+                test.strictEqual(oAsyncResult.IsSuccess, true, 'Check success of refresh item request');
+                test.strictEqual(oFile.ContentLength, 18, 'Check file content length after refresh');
+            });
+        });
+    });
+});

package/Tests/HierarchyItems/Search.js

@@ -0,0 +1,187 @@
+/**
+ * @typedef {ITHit.WebDAV.Client.WebDavSession} webDavSession
+ */
+
+QUnit.module('HierarchyItems.Search');
+
+/**
+ * @class ITHit.WebDAV.Client.Tests.HierarchyItems.Search
+ */
+ITHit.DefineClass('ITHit.WebDAV.Client.Tests.HierarchyItems.Search', null, {}, /** @lends ITHit.WebDAV.Client.Tests.HierarchyItems.Search */{
+
+    /**
+     * @param {ITHit.WebDAV.Client.WebDavSession} [webDavSession=new ITHit.WebDAV.Client.WebDavSession()]
+     * @param {string} [sFolderAbsolutePath='http://localhost:87654/']
+     * @param {function} [fCallback=function() {}]
+     */
+    SearchByString: function(webDavSession, sFolderAbsolutePath, fCallback) {
+        webDavSession.OpenFolderAsync(sFolderAbsolutePath, null, function(oFolderAsyncResult) {
+
+            /** @typedef {ITHit.WebDAV.Client.Folder} oFolder */
+            var oFolder = oFolderAsyncResult.Result;
+
+            oFolder.SearchAsync('my_file', null, function(oAsyncResult) {
+
+                /** @typedef {ITHit.WebDAV.Client.HierarchyItems[]} aItems */
+                var aItems = oAsyncResult.Result;
+
+                for (var i = 0, l = aItems.length; i < l; i++) {
+                    console.log(aItems[i].DisplayName);
+                }
+
+                fCallback(oAsyncResult);
+            });
+        });
+    },
+
+    /**
+    * @param {ITHit.WebDAV.Client.WebDavSession} [webDavSession=new ITHit.WebDAV.Client.WebDavSession()]
+    * @param {string} [sFolderAbsolutePath='http://localhost:87654/']
+    * @param {number} [offset=10]
+    * @param {number} [pageSize=5]
+    * @param {function} [fCallback=function() {}]
+    */
+    GetSearchPageByString: function (webDavSession, sFolderAbsolutePath, offset, pageSize, fCallback) {
+        webDavSession.OpenFolderAsync(sFolderAbsolutePath, null, function (oFolderAsyncResult) {
+
+            /** @typedef {ITHit.WebDAV.Client.Folder} oFolder */
+            var oFolder = oFolderAsyncResult.Result;
+
+            oFolder.GetSearchPageAsync('my_file', null, offset, pageSize, function (oPagingAsyncResult) {
+
+                /** @type {ITHit.WebDAV.Client.HierarchyItem[]} aItems */
+                var aItems = oPagingAsyncResult.Result.Page;                                // Items on the requested page.
+                /** @type {number} totalPages */
+                var totalPages = Math.ceil(oPagingAsyncResult.Result.TotalItems / pageSize); // Total number of pages.
+
+                fCallback(oAsyncResult);
+            });
+        });
+    },
+
+    /**
+     * @param {ITHit.WebDAV.Client.WebDavSession} [webDavSession=new ITHit.WebDAV.Client.WebDavSession()]
+     * @param {string} [sFolderAbsolutePath='http://localhost:87654/Products/']
+     * @param {function} [fCallback=function() {}]
+     */
+    SearchByQuery: function(webDavSession, sFolderAbsolutePath, fCallback) {
+        webDavSession.OpenFolderAsync(sFolderAbsolutePath, null, function(oFolderAsyncResult) {
+
+            /** @typedef {ITHit.WebDAV.Client.Folder} oFolder */
+            var oFolder = oFolderAsyncResult.Result;
+
+            // Build search query
+            var oSearchQuery = new ITHit.WebDAV.Client.SearchQuery('my_%');
+
+            // By default WebDAV Ajax Client search by DisplayName property.
+            // You can add other properties to this list.
+            oSearchQuery.LikeProperties.push(new ITHit.WebDAV.Client.PropertyName('creator-displayname', 'DAV:'));
+            oSearchQuery.LikeProperties.push(new ITHit.WebDAV.Client.PropertyName('comment', 'DAV:'));
+
+            // Disable search by file content
+            oSearchQuery.EnableContains = false;
+
+            oFolder.SearchByQueryAsync(oSearchQuery, function(oAsyncResult) {
+
+                /** @typedef {ITHit.WebDAV.Client.HierarchyItems[]} aItems */
+                var aItems = oAsyncResult.Result;
+
+                for (var i = 0, l = aItems.length; i < l; i++) {
+                    console.log(aItems[i].DisplayName);
+                }
+
+                fCallback(oAsyncResult);
+            });
+        });
+    },
+
+    /**
+     * @param {ITHit.WebDAV.Client.WebDavSession} [webDavSession=new ITHit.WebDAV.Client.WebDavSession()]
+     * @param {string} [sFolderAbsolutePath='http://localhost:87654/Products/']
+     * @param {number} [offset=10]
+     * @param {number} [pageSize=5]
+     * @param {function} [fCallback=function() {}]
+     */
+    GetSearchPageByQuery: function (webDavSession, sFolderAbsolutePath, offset, pageSize, fCallback) {
+        webDavSession.OpenFolderAsync(sFolderAbsolutePath, null, function (oFolderAsyncResult) {
+
+            /** @typedef {ITHit.WebDAV.Client.Folder} oFolder */
+            var oFolder = oFolderAsyncResult.Result;
+
+            // Build search query
+            var oSearchQuery = new ITHit.WebDAV.Client.SearchQuery('my_%');
+
+            // By default WebDAV Ajax Client search by DisplayName property.
+            // You can add other properties to this list.
+            oSearchQuery.LikeProperties.push(new ITHit.WebDAV.Client.PropertyName('creator-displayname', 'DAV:'));
+            oSearchQuery.LikeProperties.push(new ITHit.WebDAV.Client.PropertyName('comment', 'DAV:'));
+
+            // Disable search by file content
+            oSearchQuery.EnableContains = false;
+
+            oFolder.GetSearchPageByQueryAsync(oSearchQuery, offset, pageSize, function (oPagingAsyncResult) {
+
+                /** @type {ITHit.WebDAV.Client.HierarchyItem[]} aItems */
+                var aItems = oPagingAsyncResult.Result.Page;                                // Items on the requested page.
+                /** @type {number} totalPages */
+                var totalPages = Math.ceil(oPagingAsyncResult.Result.TotalItems / pageSize); // Total number of pages.
+
+                fCallback(oAsyncResult);
+            });
+        });
+    }
+
+});
+
+// @todo No full testing, because search indexes is not dynamically
+
+QUnitRunner.test('Search file by string or query object', function (test) {
+    QUnit.stop();
+    Helper.Create([
+        'HierarchyItems/Search/my_folder/',
+        'HierarchyItems/Search/my_file.txt',
+        'HierarchyItems/Search/my_image.jpg'
+    ], function() {
+        QUnit.start();
+
+        QUnit.stop();
+        webDavSession.OpenFolderAsync(Helper.GetAbsolutePath('HierarchyItems/Search/'), null, function(oAsyncResult) {
+            QUnit.start();
+
+            /** @typedef {ITHit.WebDAV.Client.Folder} oFolder */
+            var oFolder = oAsyncResult.Result;
+
+            QUnit.stop();
+            oFolder.GetSupportedFeaturesAsync(function(oAsyncResult) {
+                QUnit.start();
+
+                /** @typedef {ITHit.WebDAV.Client.OptionsInfo} oOptionsInfo */
+                var oOptionsInfo = oAsyncResult.Result;
+
+                if (!oOptionsInfo.Search) {
+                    ITHitTests.skip(test, 'Server does not support search.');
+                    return;
+                }
+
+                QUnit.stop();
+                ITHit.WebDAV.Client.Tests.HierarchyItems.Search.SearchByString(webDavSession, Helper.GetAbsolutePath('HierarchyItems/Search/'), function(oAsyncResult) {
+                    QUnit.start();
+
+                    test.strictEqual(oAsyncResult.IsSuccess, true, 'Check success of search by string request');
+                    /*test.strictEqual(oAsyncResult.Result.length, 1);
+                     test.strictEqual(oAsyncResult.Result[0] instanceof ITHit.WebDAV.Client.File, true);
+                     test.strictEqual(oAsyncResult.Result[0].DisplayName, 'my_file');*/
+
+                    QUnit.stop();
+                    ITHit.WebDAV.Client.Tests.HierarchyItems.Search.SearchByQuery(webDavSession, Helper.GetAbsolutePath('HierarchyItems/Search/'), function(oAsyncResult) {
+                        QUnit.start();
+
+                        test.strictEqual(oAsyncResult.IsSuccess, true, 'Check success of search by query object request');
+                        /*test.strictEqual(oAsyncResult.Result.length, 1);
+                         test.strictEqual(oAsyncResult.Result[0] instanceof ITHit.WebDAV.Client.File, true);*/
+                    });
+                });
+            });
+        });
+    });
+});

package/Tests/HierarchyItems/SupportedFeatures.js

@@ -0,0 +1,53 @@
+/**
+ * @typedef {ITHit.WebDAV.Client.WebDavSession} webDavSession
+ */
+
+QUnit.module('HierarchyItems.SupportedFeatures');
+
+/**
+ * @class ITHit.WebDAV.Client.Tests.HierarchyItems.SupportedFeatures
+ */
+ITHit.DefineClass('ITHit.WebDAV.Client.Tests.HierarchyItems.SupportedFeatures', null, {}, /** @lends ITHit.WebDAV.Client.Tests.HierarchyItems.SupportedFeatures */{
+
+    /**
+     * @param {ITHit.WebDAV.Client.WebDavSession} [webDavSession=new ITHit.WebDAV.Client.WebDavSession()]
+     * @param {string} [sFolderAbsolutePath='http://localhost:87654/']
+     * @param {function} [fCallback=function() {}]
+     */
+    SupportedFeatures: function(webDavSession, sFolderAbsolutePath, fCallback) {
+        webDavSession.OpenFolderAsync(sFolderAbsolutePath, null, function(oAsyncResult) {
+
+            /** @typedef {ITHit.WebDAV.Client.Folder} oFolder */
+            var oFolder = oAsyncResult.Result;
+
+            oFolder.GetSupportedFeaturesAsync(function(oAsyncResult) {
+
+                /** @typedef {ITHit.WebDAV.Client.OptionsInfo} oOptionsInfo */
+                var oOptionsInfo = oAsyncResult.Result;
+
+                console.log('Locking support: ' + (oOptionsInfo.Features & ITHit.WebDAV.Client.Features.Class2 !== 0 ? 'yes' : 'no'));
+                console.log('Resumable upload support: ' + (oOptionsInfo.Features & ITHit.WebDAV.Client.Features.ResumableUpload !== 0 ? 'yes' : 'no'));
+
+                fCallback(oAsyncResult);
+            });
+        });
+    }
+
+});
+
+QUnitRunner.test('Get supported features', function (test) {
+    QUnit.stop();
+    Helper.Create([
+        'HierarchyItems/'
+    ], function() {
+        QUnit.start();
+
+        QUnit.stop();
+        ITHit.WebDAV.Client.Tests.HierarchyItems.SupportedFeatures.SupportedFeatures(webDavSession, Helper.GetAbsolutePath('HierarchyItems/'), function(oAsyncResult) {
+            QUnit.start();
+
+            test.strictEqual(oAsyncResult.IsSuccess, true, 'Check success of get supported features request');
+            test.strictEqual(oAsyncResult.Result instanceof ITHit.WebDAV.Client.OptionsInfo, true, 'Check result is instance of OptionsInfo');
+        });
+    });
+});