webdav.client 5.20.5664

package/Tests/HierarchyItems/Delete.js

@@ -0,0 +1,73 @@
+/**
+ * @typedef {ITHit.WebDAV.Client.WebDavSession} webDavSession
+ */
+
+QUnit.module('HierarchyItems.Delete');
+
+/**
+ * @class ITHit.WebDAV.Client.Tests.HierarchyItems.Delete
+ */
+ITHit.DefineClass('ITHit.WebDAV.Client.Tests.HierarchyItems.Delete', null, {}, /** @lends ITHit.WebDAV.Client.Tests.HierarchyItems.Delete */{
+
+    /**
+     * @param {ITHit.WebDAV.Client.WebDavSession} [webDavSession=new ITHit.WebDAV.Client.WebDavSession()]
+     * @param {string} [sFolderAbsolutePath='http://localhost:87654/my_folder/']
+     * @param {function} [fCallback=function() {}]
+     */
+    Delete: function(webDavSession, sFolderAbsolutePath, fCallback) {
+        webDavSession.OpenFolderAsync(sFolderAbsolutePath, null, function(oAsyncResult) {
+
+            /** @typedef {ITHit.WebDAV.Client.Folder} oFolder */
+            var oFolder = oAsyncResult.Result;
+
+            oFolder.DeleteAsync(null, function(oAsyncResult) {
+
+                if (oAsyncResult.IsSuccess) {
+                    console.log('Folder successfully deleted.');
+                } else if (oAsyncResult.Error instanceof ITHit.WebDAV.Client.Exceptions.WebDavHttpException) {
+                    var sErrorText = oAsyncResult.Error.Message + ' ' + oAsyncResult.Error.Status.Code + ' ' +
+                        oAsyncResult.Error.Status.Description;
+
+                    // Find which items failed to delete.
+                    for(var i = 0, l = oAsyncResult.Error.Multistatus.Responses.length; i < l; i++) {
+                        var oResponse = oAsyncResult.Error.Multistatus.Responses[i];
+                        sErrorText += '\n' + oResponse.Href + ' ' + oResponse.Status.Code + ' ' +
+                        oResponse.Status.Description;
+                    }
+
+                    console.log('Delete error: ' + sErrorText);
+                } else {
+                    console.log('Delete error: ' + String(oAsyncResult.Error));
+                }
+
+                fCallback(oAsyncResult);
+            });
+        });
+    }
+
+});
+
+QUnitRunner.test('Delete folder and check it not found', function (test) {
+    QUnit.stop();
+    Helper.Create([
+        'HierarchyItems/Delete/my_folder/'
+    ], function() {
+        QUnit.start();
+
+        QUnit.stop();
+        ITHit.WebDAV.Client.Tests.HierarchyItems.Delete.Delete(webDavSession, Helper.GetAbsolutePath('HierarchyItems/Delete/my_folder/'), function(oAsyncResult) {
+            QUnit.start();
+
+            test.strictEqual(oAsyncResult.IsSuccess, true, 'Check success of delete request');
+
+            QUnit.stop();
+            webDavSession.OpenFolderAsync(Helper.GetAbsolutePath('HierarchyItems/Delete/my_folder/'), null, function(oAsyncResult) {
+                QUnit.start();
+
+                test.strictEqual(oAsyncResult.IsSuccess, false, 'Check failure request on get deleted folder');
+                test.strictEqual(oAsyncResult.Error instanceof ITHit.WebDAV.Client.Exceptions.NotFoundException, true, 'Check error is NotFoundException');
+
+            });
+        });
+    });
+});

package/Tests/HierarchyItems/GetFolderItems.js

@@ -0,0 +1,87 @@
+/**
+ * @typedef {ITHit.WebDAV.Client.WebDavSession} webDavSession
+ */
+
+QUnit.module('HierarchyItems.GetFolderItems');
+
+/**
+ * @class ITHit.WebDAV.Client.Tests.HierarchyItems.GetFolderItems
+ */
+ITHit.DefineClass('ITHit.WebDAV.Client.Tests.HierarchyItems.GetFolderItems', null, {}, /** @lends ITHit.WebDAV.Client.Tests.HierarchyItems.GetFolderItems */{
+
+    /**
+     * @param {ITHit.WebDAV.Client.WebDavSession} [webDavSession=new ITHit.WebDAV.Client.WebDavSession()]
+     * @param {string} [sFolderAbsolutePath='http://localhost:87654/']
+     * @param {function} [fCallback=function() {}]
+     */
+    GetChildren: function(webDavSession, sFolderAbsolutePath, fCallback) {
+        webDavSession.OpenFolderAsync(sFolderAbsolutePath, null, function(oFolderAsyncResult) {
+
+            /** @typedef {ITHit.WebDAV.Client.Folder} oFolder */
+            var oFolder = oFolderAsyncResult.Result;
+
+            oFolder.GetChildrenAsync(null, null, function(oItemsAsyncResult) {
+
+                /** @typedef {ITHit.WebDAV.Client.HierarchyItems[]} aItems */
+                var aItems = oItemsAsyncResult.Result;
+
+                for (var i = 0, l = aItems.length; i < l; i++) {
+                    console.log(aItems[i].DisplayName);
+                }
+
+                fCallback(oItemsAsyncResult);
+            });
+        });
+    },
+
+    /**
+    * @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 {ITHit.WebDAV.Client.OrderProperty[]} [sortColumns=[new ITHit.WebDAV.Client.OrderProperty(new ITHit.WebDAV.Client.PropertyName('name', 'myNs'), true)]]
+    * @param {function} [fCallback=function() {}]
+    */
+    GetPage: function (webDavSession, sFolderAbsolutePath, offset, pageSize, sortColumns, fCallback) {
+        webDavSession.OpenFolderAsync(sFolderAbsolutePath, null, function (oFolderAsyncResult) {
+
+            /** @typedef {ITHit.WebDAV.Client.Folder} oFolder */
+            var oFolder = oFolderAsyncResult.Result;
+
+            oFolder.GetPageAsync(null, offset, pageSize, sortColumns, 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.
+            });
+        });
+    }
+});
+
+QUnitRunner.test('List folder content', function (test) {
+    QUnit.stop();
+    Helper.Create([
+        'HierarchyItems/GetChildren/item1.txt',
+        'HierarchyItems/GetChildren/item2.txt'
+    ], function() {
+        QUnit.start();
+
+        QUnit.stop();
+        ITHit.WebDAV.Client.Tests.HierarchyItems.GetFolderItems.GetChildren(webDavSession, Helper.GetAbsolutePath('HierarchyItems/GetChildren/'), function(oAsyncResult) {
+            QUnit.start();
+
+            test.strictEqual(oAsyncResult.IsSuccess, true, 'Check success of get children request');
+            test.strictEqual(oAsyncResult.Result.length, 2, 'Check children length');
+
+            var aFileNames = [];
+            for (var i = 0, l = oAsyncResult.Result.length; i < l; i++) {
+                aFileNames.push(oAsyncResult.Result[i].DisplayName);
+            }
+
+            aFileNames = aFileNames.sort();
+            test.strictEqual(aFileNames[0], 'item1.txt', 'Check first child name');
+            test.strictEqual(aFileNames[1], 'item2.txt', 'Check second child name');
+        });
+    });
+});

package/Tests/HierarchyItems/GetHeadRequests.js

@@ -0,0 +1,73 @@
+/**
+ * @typedef {ITHit.WebDAV.Client.WebDavSession} webDavSession
+ */
+
+QUnit.module('HierarchyItems.GetHeadRequests');
+
+/**
+ * @class ITHit.WebDAV.Client.Tests.HierarchyItems.GetHeadRequests
+ */
+ITHit.DefineClass('ITHit.WebDAV.Client.Tests.HierarchyItems.GetHeadRequests', null, {}, /** @lends ITHit.WebDAV.Client.Tests.HierarchyItems.GetHeadRequests */{
+
+    XhrSend: function(method, sPath, fCallback) {
+        var xhr = new XMLHttpRequest();
+        xhr.open(method, sPath, true);
+        xhr.onreadystatechange = function() {
+            if (xhr.readyState === 4) {
+                var oHeaders = {};
+                var aHeaders = xhr.getAllResponseHeaders().split('\n');
+                for (var i = 0; i < aHeaders.length; i++) {
+                    var aParts = aHeaders[i].split(':');
+                    if (aParts.length > 1) {
+                        oHeaders[aParts.shift()] = aParts.join(':').replace(/^\s+|\s+$/g, '');
+                    }
+                }
+
+                fCallback(xhr, oHeaders);
+            }
+        };
+        xhr.send();
+    }
+
+});
+
+QUnitRunner.test('Check GET request support on folder', function (test) {
+    var sFilePath = 'HierarchyItems/GetHeadRequests/';
+    Helper.Create(sFilePath, QUnitRunner.async(function () {
+
+        ITHit.WebDAV.Client.Tests.HierarchyItems.GetHeadRequests.XhrSend('GET', Helper.GetAbsolutePath(sFilePath), QUnitRunner.async(function (xhr) {
+
+            test.strictEqual(xhr.status, 200, 'Check response status');
+        }));
+    }));
+});
+
+
+QUnitRunner.test('Check HEAD support on folder', function (test) {
+    var sFilePath = 'HierarchyItems/GetHeadRequests/';
+    Helper.Create(sFilePath, QUnitRunner.async(function () {
+
+        ITHit.WebDAV.Client.Tests.HierarchyItems.GetHeadRequests.XhrSend('HEAD', Helper.GetAbsolutePath(sFilePath), QUnitRunner.async(function (xhr, oHeadHeaders) {
+
+            test.strictEqual(xhr.status, 200, 'Check response status');
+
+            ITHit.WebDAV.Client.Tests.HierarchyItems.GetHeadRequests.XhrSend('GET', Helper.GetAbsolutePath(sFilePath), QUnitRunner.async(function (xhr, oGetHeaders) {
+
+                test.strictEqual(xhr.status, 200, 'Check response status');
+
+                var  aHeaders = [
+                    'Content-Type',
+                    'Last-Modified',
+                    'etag'
+                ];
+                for (var i = 0, l = aHeaders.length; i < l; i++) {
+                    if (oHeadHeaders[aHeaders[i]] && oGetHeaders[aHeaders[i]]) {
+                        test.strictEqual(oHeadHeaders[aHeaders[i]], oGetHeaders[aHeaders[i]], 'Check "' + aHeaders[i] + '" header equals on HEAD and GET requests');
+                    } else {
+                        console.error('Header "' + aHeaders[i] + '" is not support');
+                    }
+                }
+            }));
+        }));
+    }));
+});

package/Tests/HierarchyItems/GetItemByFolder.js

@@ -0,0 +1,91 @@
+/**
+ * @typedef {ITHit.WebDAV.Client.WebDavSession} webDavSession
+ */
+
+QUnit.module('HierarchyItems.GetItemByFolder');
+
+/**
+ * @class ITHit.WebDAV.Client.Tests.HierarchyItems.GetItemByFolder
+ */
+ITHit.DefineClass('ITHit.WebDAV.Client.Tests.HierarchyItems.GetItemByFolder', null, {}, /** @lends ITHit.WebDAV.Client.Tests.HierarchyItems.GetItemByFolder */{
+
+    /**
+     * @param {ITHit.WebDAV.Client.WebDavSession} [webDavSession=new ITHit.WebDAV.Client.WebDavSession()]
+     * @param {string} [sFolderAbsolutePath='http://localhost:87654/Products/']
+     * @param {string} [sFileName='myfile.txt']
+     * @param {function} [fCallback=function() {}]
+     */
+    GetFile: function(webDavSession, sFolderAbsolutePath, sFileName, fCallback) {
+        webDavSession.OpenFolderAsync(sFolderAbsolutePath, null, function(oFolderAsyncResult) {
+
+            /** @typedef {ITHit.WebDAV.Client.Folder} oFolder */
+            var oFolder = oFolderAsyncResult.Result;
+
+            oFolder.GetFileAsync(sFileName, function(oFileAsyncResult) {
+
+                /** @typedef {ITHit.WebDAV.Client.File} oFile */
+                var oFile = oFileAsyncResult.Result;
+
+                console.log('File `' + oFile.DisplayName + '` successful loaded from folder `' + oFolder.DisplayName + '`.');
+
+                fCallback(oFileAsyncResult);
+            });
+        });
+    }
+
+});
+
+QUnitRunner.test('Get item using Folder', function (test) {
+    QUnit.stop();
+    Helper.Create([
+        'HierarchyItems/GetItemByFolder/my_folder/',
+        'HierarchyItems/GetItemByFolder/my_file.txt'
+    ], function() {
+        QUnit.start();
+
+        QUnit.stop();
+        webDavSession.OpenFolderAsync(Helper.GetAbsolutePath('HierarchyItems/GetItemByFolder/'), null, function(oAsyncResult) {
+            QUnit.start();
+
+            /** @typedef {ITHit.WebDAV.Client.Folder} oFolder */
+            var oFolder = oAsyncResult.Result;
+
+            QUnit.stop();
+            oFolder.GetItemAsync('my_folder', function(oAsyncResult) {
+                QUnit.start();
+                test.strictEqual(oAsyncResult.Result instanceof ITHit.WebDAV.Client.Folder, true, 'Check result is instance of Folder');
+
+                QUnit.stop();
+                oFolder.GetItemAsync('my_file.txt', function(oAsyncResult) {
+                    QUnit.start();
+                    test.strictEqual(oAsyncResult.Result instanceof ITHit.WebDAV.Client.File, true, 'Check result is instance of File');
+
+                    QUnit.stop();
+                    oFolder.GetFolderAsync('my_folder', function(oAsyncResult) {
+                        QUnit.start();
+                        test.strictEqual(oAsyncResult.Result instanceof ITHit.WebDAV.Client.Folder, true, 'Check result is instance of Folder');
+
+                        QUnit.stop();
+                        ITHit.WebDAV.Client.Tests.HierarchyItems.GetItemByFolder.GetFile(webDavSession, Helper.GetAbsolutePath('HierarchyItems/GetItemByFolder/'), 'my_file.txt', function(oAsyncResult) {
+                            QUnit.start();
+
+                            test.strictEqual(oAsyncResult.Result instanceof ITHit.WebDAV.Client.File, true, 'Check result is instance of File');
+
+                            QUnit.stop();
+                            oFolder.GetFileAsync('my_folder', function(oAsyncResult) {
+                                QUnit.start();
+                                test.strictEqual(oAsyncResult.Error instanceof ITHit.WebDAV.Client.Exceptions.WebDavException, true, 'Check error is WebDavException on get folder by GetFile method');
+
+                                QUnit.stop();
+                                oFolder.GetFolderAsync('my_file.txt', function(oAsyncResult) {
+                                    QUnit.start();
+                                    test.strictEqual(oAsyncResult.Error instanceof ITHit.WebDAV.Client.Exceptions.WebDavException, true, 'Check error is WebDavException on get file by GetFolder method');
+                                });
+                            });
+                        });
+                    });
+                });
+            });
+        });
+    });
+});

package/Tests/HierarchyItems/GetItemBySession.js

@@ -0,0 +1,135 @@
+/**
+ * @typedef {ITHit.WebDAV.Client.WebDavSession} webDavSession
+ */
+
+QUnit.module('HierarchyItems.GetItemBySession');
+
+/**
+ * @class ITHit.WebDAV.Client.Tests.HierarchyItems.GetItemBySession
+ */
+ITHit.DefineClass('ITHit.WebDAV.Client.Tests.HierarchyItems.GetItemBySession', null, {}, /** @lends ITHit.WebDAV.Client.Tests.HierarchyItems.GetItemBySession */{
+
+    /**
+     * @param {ITHit.WebDAV.Client.WebDavSession} [webDavSession=new ITHit.WebDAV.Client.WebDavSession()]
+     * @param {string} [sFolderAbsolutePath='http://localhost:87654/Documents/']
+     * @param {function} [fCallback=function() {}]
+     */
+    GetFolder: function(webDavSession, sFolderAbsolutePath, fCallback) {
+        webDavSession.OpenFolderAsync(sFolderAbsolutePath, null, function(oAsyncResult) {
+
+            /** @typedef {ITHit.WebDAV.Client.Folder} oFolder */
+            var oFolder = oAsyncResult.Result;
+
+            console.log('Loaded folder `' + oFolder.DisplayName + '`.');
+
+            fCallback(oAsyncResult);
+        });
+    }
+
+});
+
+QUnitRunner.test('Get item using WebDavSession', function (test) {
+    QUnit.stop();
+    Helper.Create([
+        'HierarchyItems/GetItemBySession/item1.txt'
+    ], function() {
+        QUnit.start();
+
+        QUnit.stop();
+        webDavSession.OpenItemAsync(Helper.GetAbsolutePath('HierarchyItems/GetItemBySession/'), null, function(oAsyncResult) {
+            QUnit.start();
+            test.strictEqual(oAsyncResult.Result instanceof ITHit.WebDAV.Client.Folder, true, 'Check result is instance of Folder');
+
+            QUnit.stop();
+            webDavSession.OpenItemAsync(Helper.GetAbsolutePath('HierarchyItems/GetItemBySession/item1.txt'), null, function(oAsyncResult) {
+                QUnit.start();
+                test.strictEqual(oAsyncResult.Result instanceof ITHit.WebDAV.Client.File, true, 'Check result is instance of File');
+
+                QUnit.stop();
+                ITHit.WebDAV.Client.Tests.HierarchyItems.GetItemBySession.GetFolder(webDavSession, Helper.GetAbsolutePath('HierarchyItems/GetItemBySession/'), function(oAsyncResult) {
+                    QUnit.start();
+                    test.strictEqual(oAsyncResult.Result instanceof ITHit.WebDAV.Client.Folder, true, 'Check result is instance of Folder');
+
+                    QUnit.stop();
+                    webDavSession.OpenFileAsync(Helper.GetAbsolutePath('HierarchyItems/GetItemBySession/item1.txt'), null, function(oAsyncResult) {
+                        QUnit.start();
+                        test.strictEqual(oAsyncResult.Result instanceof ITHit.WebDAV.Client.File, true, 'Check result is instance of File');
+
+                        QUnit.stop();
+                        webDavSession.OpenFileAsync(Helper.GetAbsolutePath('HierarchyItems/GetItemBySession/'), null, function(oAsyncResult) {
+                            QUnit.start();
+                            test.strictEqual(oAsyncResult.Error instanceof ITHit.WebDAV.Client.Exceptions.WebDavException, true, 'Check error is WebDavException on get folder by OpenFile method');
+
+                            QUnit.stop();
+                            webDavSession.OpenFolderAsync(Helper.GetAbsolutePath('HierarchyItems/GetItemBySession/item1.txt'), null, function(oAsyncResult) {
+                                QUnit.start();
+                                test.strictEqual(oAsyncResult.Error instanceof ITHit.WebDAV.Client.Exceptions.WebDavException, true, 'Check error is WebDavException on get file by OpenFolder method');
+                            });
+                        });
+                    });
+                });
+            });
+        });
+    });
+});
+
+QUnitRunner.test('Check NotFound exception by session calls', function (test) {
+    QUnit.stop();
+    webDavSession.OpenItemAsync(Helper.GetAbsolutePath('HierarchyItems/GetItemBySession/not-found/'), null, function(oAsyncResult) {
+        QUnit.start();
+
+        test.strictEqual(oAsyncResult.IsSuccess, false, 'Check failure on open not found item request');
+        test.strictEqual(oAsyncResult.Error instanceof ITHit.WebDAV.Client.Exceptions.NotFoundException, true, 'Check error is NotFoundException');
+
+        QUnit.stop();
+        webDavSession.OpenFolderAsync(Helper.GetAbsolutePath('HierarchyItems/GetItemBySession/not-found/'), null, function(oAsyncResult) {
+            QUnit.start();
+
+            test.strictEqual(oAsyncResult.IsSuccess, false, 'Check failure on open not found folder request');
+            test.strictEqual(oAsyncResult.Error instanceof ITHit.WebDAV.Client.Exceptions.NotFoundException, true, 'Check error is NotFoundException');
+
+
+            QUnit.stop();
+            webDavSession.OpenFileAsync(Helper.GetAbsolutePath('HierarchyItems/GetItemBySession/not-found.txt'), null, function(oAsyncResult) {
+                QUnit.start();
+
+                test.strictEqual(oAsyncResult.IsSuccess, false, 'Check failure on open not found file request');
+                test.strictEqual(oAsyncResult.Error instanceof ITHit.WebDAV.Client.Exceptions.NotFoundException, true, 'Check error is NotFoundException');
+            });
+        });
+    });
+});
+
+QUnitRunner.test('Get item using WebDavSession, with parameters in URL', function (test) {
+    QUnit.stop();
+    Helper.Create([
+        'HierarchyItems/GetItemBySession/param1.txt'
+    ], function() {
+        QUnit.start();
+
+        QUnit.stop();
+        webDavSession.OpenItemAsync(Helper.GetAbsolutePath('HierarchyItems/GetItemBySession/param1.txt?param1=1&param2=2'), null, function(oAsyncResult) {
+            QUnit.start();
+
+            test.strictEqual(oAsyncResult.IsSuccess, true, 'Check success of open item with params request');
+            test.strictEqual(oAsyncResult.Result instanceof ITHit.WebDAV.Client.File, true, 'Check result is instance of File');
+
+            QUnit.stop();
+            webDavSession.OpenFolderAsync(Helper.GetAbsolutePath('HierarchyItems/GetItemBySession/?param1=1&param2=2'), null, function(oAsyncResult) {
+                QUnit.start();
+
+                test.strictEqual(oAsyncResult.IsSuccess, true, 'Check success of open folder with params request');
+                test.strictEqual(oAsyncResult.Result instanceof ITHit.WebDAV.Client.Folder, true, 'Check result is instance of Folder');
+
+
+                QUnit.stop();
+                webDavSession.OpenFileAsync(Helper.GetAbsolutePath('HierarchyItems/GetItemBySession/param1.txt?param1=1&param2=2'), null, function(oAsyncResult) {
+                    QUnit.start();
+
+                    test.strictEqual(oAsyncResult.IsSuccess, true, 'Check success of open file with params request');
+                    test.strictEqual(oAsyncResult.Result instanceof ITHit.WebDAV.Client.File, true, 'Check result is instance of File');
+                });
+            });
+        });
+    });
+});

package/Tests/HierarchyItems/GetParent.js

@@ -0,0 +1,58 @@
+/**
+ * @typedef {ITHit.WebDAV.Client.WebDavSession} webDavSession
+ */
+
+QUnit.module('HierarchyItems.GetParent');
+
+/**
+ * @class ITHit.WebDAV.Client.Tests.HierarchyItems.GetParent
+ */
+ITHit.DefineClass('ITHit.WebDAV.Client.Tests.HierarchyItems.GetParent', null, {}, /** @lends ITHit.WebDAV.Client.Tests.HierarchyItems.GetParent */{
+
+    /**
+     * @param {ITHit.WebDAV.Client.WebDavSession} [webDavSession=new ITHit.WebDAV.Client.WebDavSession()]
+     * @param {string} [sFolderAbsolutePath='http://localhost:87654/my_folder/']
+     * @param {function} [fCallback=function() {}]
+     */
+    GetParent: function(webDavSession, sFolderAbsolutePath, fCallback) {
+        webDavSession.OpenFolderAsync(sFolderAbsolutePath, null, function(oFolderAsyncResult) {
+
+            /** @typedef {ITHit.WebDAV.Client.Folder} oFolder */
+            var oFolder = oFolderAsyncResult.Result;
+
+            oFolder.GetParentAsync(null, function(oParentAsyncResult) {
+
+                /** @typedef {ITHit.WebDAV.Client.Folder} oParentFolder */
+                var oParentFolder = oParentAsyncResult.Result;
+
+                console.log('Parent folder: ' + oParentFolder.DisplayName);
+
+                oParentFolder.GetParentAsync(null, function(oParentParentAsyncResult) {
+
+                    /** @typedef {ITHit.WebDAV.Client.Folder} oParentFolder */
+                    var oParentParentFolder = oParentParentAsyncResult.Result;
+
+                    if (oParentParentFolder === null) {
+                        console.log('Folder is root!');
+                    }
+
+                    fCallback(oParentAsyncResult, oParentParentAsyncResult);
+                });
+            });
+        });
+    }
+
+});
+
+QUnitRunner.test('Get parent folder', function (test) {
+    QUnit.stop();
+    ITHit.WebDAV.Client.Tests.HierarchyItems.GetParent.GetParent(webDavSession, Helper.GetAbsolutePath(''), function(oParentAsyncResult, oParentParentAsyncResult) {
+        QUnit.start();
+
+        test.strictEqual(oParentAsyncResult.IsSuccess, true, 'Check success of first get parent folder request');
+        test.strictEqual(oParentAsyncResult.Result instanceof ITHit.WebDAV.Client.Folder, true, 'Check result is instance of Folder');
+        test.strictEqual(oParentParentAsyncResult.IsSuccess, true, 'Check success of second get parent folder request');
+
+        //test.strictEqual(oParentParentAsyncResult.Result, null, 'Check result is null - root folder'); // Root folder can be is folder
+    });
+});

package/Tests/HierarchyItems/ItemExists.js

@@ -0,0 +1,73 @@
+/**
+ * @typedef {ITHit.WebDAV.Client.WebDavSession} webDavSession
+ */
+
+QUnit.module('HierarchyItems.ItemExists');
+
+/**
+ * @class ITHit.WebDAV.Client.Tests.HierarchyItems.ItemExists
+ */
+ITHit.DefineClass('ITHit.WebDAV.Client.Tests.HierarchyItems.ItemExists', null, {}, /** @lends ITHit.WebDAV.Client.Tests.HierarchyItems.ItemExists */{
+
+    /**
+     * @param {ITHit.WebDAV.Client.WebDavSession} [webDavSession=new ITHit.WebDAV.Client.WebDavSession()]
+     * @param {string} [sFolderAbsolutePath='http://localhost:87654/']
+     * @param {function} [fCallback=function() {}]
+     */
+    ItemExists: function(webDavSession, sFolderAbsolutePath, fCallback) {
+        webDavSession.OpenFolderAsync(sFolderAbsolutePath, null, function(oAsyncResult) {
+
+            /** @typedef {ITHit.WebDAV.Client.Folder} oFolder */
+            var oFolder = oAsyncResult.Result;
+
+            oFolder.ItemExistsAsync('my_folder', function(oAsyncResult) {
+
+                if (oAsyncResult.Result) {
+                    console.log('Item exists');
+                } else {
+                    console.log('Item not found');
+                }
+
+                fCallback(oAsyncResult);
+            });
+        });
+    }
+
+});
+
+QUnitRunner.test('Item exists', function (test) {
+    QUnit.stop();
+    Helper.Create([
+        'HierarchyItems/ItemExists/'
+    ], function() {
+        QUnit.start();
+
+        QUnit.stop();
+        ITHit.WebDAV.Client.Tests.HierarchyItems.ItemExists.ItemExists(webDavSession, Helper.GetAbsolutePath('HierarchyItems/ItemExists/'), function(oAsyncResult) {
+            QUnit.start();
+
+            test.strictEqual(oAsyncResult.IsSuccess, true, 'Check success of item exists request');
+            test.strictEqual(oAsyncResult.Result, false, 'Check result is false - not found folder');
+
+            // Create folder
+            QUnit.stop();
+            webDavSession.OpenFolderAsync(Helper.GetAbsolutePath('HierarchyItems/ItemExists/'), null, function(oAsyncResult) {
+                var oFolder = oAsyncResult.Result;
+                oFolder.CreateFolderAsync('my_folder', null, null, function(oAsyncResult) {
+                    QUnit.start();
+
+                    test.strictEqual(oAsyncResult.IsSuccess, true, 'Check success of create folder request');
+
+                    QUnit.stop();
+                    ITHit.WebDAV.Client.Tests.HierarchyItems.ItemExists.ItemExists(webDavSession, Helper.GetAbsolutePath('HierarchyItems/ItemExists/'), function(oAsyncResult) {
+                        QUnit.start();
+
+                        test.strictEqual(oAsyncResult.IsSuccess, true, 'Check success of item exists request');
+                        test.strictEqual(oAsyncResult.Result, true, 'Check result is true - folder is exists');
+
+                    });
+                });
+            });
+        });
+    });
+});

package/Tests/HierarchyItems/MicrosoftOfficeDiscovery.js

@@ -0,0 +1,51 @@
+/**
+ * @typedef {ITHit.WebDAV.Client.WebDavSession} webDavSession
+ */
+
+QUnit.module('HierarchyItems.MicrosoftOfficeDiscovery');
+
+/**
+ * @class ITHit.WebDAV.Client.Tests.HierarchyItems.MicrosoftOfficeDiscovery
+ */
+ITHit.DefineClass('ITHit.WebDAV.Client.Tests.HierarchyItems.MicrosoftOfficeDiscovery', null, {}, /** @lends ITHit.WebDAV.Client.Tests.HierarchyItems.MicrosoftOfficeDiscovery */{
+
+	OpenParent: function (test, sPath) {
+		QUnit.stop();
+		webDavSession.OpenFolderAsync(sPath, null, function(oAsyncResult) {
+			QUnit.start();
+
+			test.strictEqual(oAsyncResult.IsSuccess, true, 'Check success of open folder request (PROPFIND) to `' + sPath + '`');
+
+			/** @typedef {ITHit.WebDAV.Client.Folder} oFolder */
+			var oFolder = oAsyncResult.Result;
+
+			if (!oFolder) {
+				return;
+			}
+
+			QUnit.stop();
+			oFolder.GetSupportedFeaturesAsync(function(oAsyncResult) {
+				QUnit.start();
+
+				test.strictEqual(oAsyncResult.IsSuccess, true, 'Check success of supported features request (OPTIONS) to `' + sPath + '`');
+
+				var sParentPath = ITHit.WebDAV.Client.HierarchyItem.GetFolderParentUri(sPath);
+				if (sParentPath !== null) {
+					ITHit.WebDAV.Client.Tests.HierarchyItems.MicrosoftOfficeDiscovery.OpenParent(test, sParentPath);
+				}
+			})
+		});
+	}
+
+});
+
+QUnitRunner.test('Microsoft Office discovery', function (test) {
+	QUnit.stop();
+	Helper.Create([
+		'Ms/Office/'
+	], function() {
+		QUnit.start();
+
+		ITHit.WebDAV.Client.Tests.HierarchyItems.MicrosoftOfficeDiscovery.OpenParent(test, Helper.GetAbsolutePath('Ms/Office/'));
+	});
+});