webdav.client 5.20.5664

package/Tests/Upload/GetBytesUploaded.js

@@ -0,0 +1,47 @@
+/**
+ * @typedef {ITHit.WebDAV.Client.WebDavSession} webDavSession
+ */
+
+QUnit.module('Upload.GetBytesUploaded');
+
+QUnitRunner.test('Get bytes uploaded on created file', function (test) {
+    QUnit.stop();
+    Helper.Create([
+        'Upload/bytes_file.txt'
+    ], function() {
+        QUnit.start();
+
+        QUnit.stop();
+        webDavSession.OpenItemAsync(Helper.GetAbsolutePath('Upload/bytes_file.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');
+
+            // Async variant
+            QUnit.stop();
+
+            oFile.GetSupportedFeaturesAsync(function (oAsyncResult) {
+                QUnit.start();
+
+                /** @typedef {ITHit.WebDAV.Client.OptionsInfo} oOptionsInfo */
+                var oOptionsInfo = oAsyncResult.Result;
+
+                if ((oOptionsInfo.Features & ITHit.WebDAV.Client.Features.ResumableUpload) === 0) {
+                    ITHitTests.skip(test, 'Server does not support resumable upload.');
+                    return;
+                }
+
+                QUnit.stop();
+                oFile.ResumableUpload.GetBytesUploadedAsync(function (oAsyncResult) {
+                    QUnit.start();
+
+                    test.strictEqual(oAsyncResult.IsSuccess, true, 'Check success of get bytes request');
+                    test.strictEqual(oAsyncResult.Result, 6, 'Check content length in result');
+                });
+            });
+        });
+    });
+});

package/Tests/Versions/GetVersions.js

@@ -0,0 +1,84 @@
+/**
+ * @typedef {ITHit.WebDAV.Client.WebDavSession} webDavSession
+ */
+
+QUnit.module('Versions.GetVersions');
+
+/**
+ * @class ITHit.WebDAV.Client.Tests.Versions.GetVersions
+ */
+ITHit.DefineClass('ITHit.WebDAV.Client.Tests.Versions.GetVersions', null, {}, /** @lends ITHit.WebDAV.Client.Tests.Versions.GetVersions */{
+
+    /**
+     * @param {ITHit.WebDAV.Client.WebDavSession} [webDavSession=new ITHit.WebDAV.Client.WebDavSession()]
+     * @param {string} [sFolderAbsolutePath='http://localhost:87654/myfile.txt']
+     * @param {function} [fCallback=function() {}]
+     */
+    GetVersions: function(webDavSession, sFolderAbsolutePath, fCallback) {
+        webDavSession.OpenFileAsync(sFolderAbsolutePath, null, function(oFileAsyncResult) {
+
+            /** @typedef {ITHit.WebDAV.Client.File} oFile */
+            var oFile = oFileAsyncResult.Result;
+
+            oFile.GetVersionsAsync(function(oAsyncResult) {
+
+                /** @typedef {ITHit.WebDAV.Client.Version[]} aVersions */
+                var aVersions = oAsyncResult.Result;
+
+                for (var i = 0, l = aVersions.length; i < l; i++) {
+                    var oVersion = aVersions[i];
+
+                    console.log([
+                        'Version Name: ' + oVersion.VersionName,
+                        'Comment: ' + oVersion.Comment,
+                        'Author: ' + oVersion.CreatorDisplayName,
+                        'Created: ' + oVersion.CreationDate
+                    ].join('\n'));
+                }
+
+                fCallback(oAsyncResult);
+            });
+        });
+    }
+
+});
+
+QUnitRunner.test('Get file versions list', function (test) {
+    QUnit.stop();
+    Helper.Create([
+        'Versions/ver.txt'
+    ], function() {
+        QUnit.start();
+
+        QUnit.stop();
+        webDavSession.OpenFileAsync(Helper.GetAbsolutePath('Versions/ver.txt'), null, function(oAsyncResult) {
+            QUnit.start();
+
+            /** @typedef {ITHit.WebDAV.Client.File} oFile */
+            var oFile = oAsyncResult.Result;
+
+            QUnit.stop();
+            Helper.CheckVersionsSupported(oFile, function(bIsVersionSupported) {
+                QUnit.start();
+
+                if (!bIsVersionSupported) {
+                    ITHitTests.skip(test, 'Server does not support versions.');
+                    return;
+                }
+
+                test.strictEqual(oAsyncResult.IsSuccess, true, 'Check success of open item request');
+                test.strictEqual(oFile instanceof ITHit.WebDAV.Client.HierarchyItem, true, 'Check result is instance of HierarchyItem');
+
+                QUnit.stop();
+                ITHit.WebDAV.Client.Tests.Versions.GetVersions.GetVersions(webDavSession, Helper.GetAbsolutePath('Versions/ver.txt'), function(oAsyncResult) {
+                    QUnit.start();
+
+                    var oVersion = oAsyncResult.Result[0];
+
+                    test.strictEqual(oAsyncResult.IsSuccess, true, 'Check success of get versions request');
+                    test.strictEqual(oVersion instanceof ITHit.WebDAV.Client.Version, true, 'Check result item is instance of Version');
+                });
+            });
+        });
+    });
+});

package/Tests/Versions/ManageVersions.js

@@ -0,0 +1,180 @@
+/**
+ * @typedef {ITHit.WebDAV.Client.WebDavSession} webDavSession
+ */
+
+QUnit.module('Versions.ManageVersions');
+
+/**
+ * @class ITHit.WebDAV.Client.Tests.Versions.ManageVersions
+ */
+ITHit.DefineClass('ITHit.WebDAV.Client.Tests.Versions.ManageVersions', null, {}, /** @lends ITHit.WebDAV.Client.Tests.Versions.ManageVersions */{
+
+    /**
+     * @param {ITHit.WebDAV.Client.WebDavSession} [webDavSession=new ITHit.WebDAV.Client.WebDavSession()]
+     * @param {string} [sFolderAbsolutePath='http://localhost:87654/myfile.txt']
+     * @param {function} [fCallback=function() {}]
+     */
+    UpdateToThis: function(webDavSession, sFolderAbsolutePath, fCallback) {
+        webDavSession.OpenFileAsync(sFolderAbsolutePath, null, function(oFileAsyncResult) {
+
+            /** @typedef {ITHit.WebDAV.Client.File} oFile */
+            var oFile = oFileAsyncResult.Result;
+
+            oFile.GetVersionsAsync(function(oAsyncResult) {
+
+                /** @typedef {ITHit.WebDAV.Client.Version[]} aVersions */
+                var aVersions = oAsyncResult.Result;
+
+                /** @typedef {ITHit.WebDAV.Client.Version} oLastVersion */
+                var oLastVersion = aVersions[aVersions.length - 1];
+
+                oLastVersion.UpdateToThisAsync(function(oAsyncResult) {
+
+                    if (oAsyncResult.IsSuccess) {
+                        console.log('File `' + oFile.DisplayName + '` successfully updated to version `' + oLastVersion.VersionName + '`');
+                    }
+
+                    fCallback(oAsyncResult);
+                });
+            });
+        });
+    },
+
+    /**
+     * @param {ITHit.WebDAV.Client.WebDavSession} [webDavSession=new ITHit.WebDAV.Client.WebDavSession()]
+     * @param {string} [sFolderAbsolutePath='http://localhost:87654/myfile.txt']
+     * @param {string} [sVersionHref='http://localhost:87654/myfile.txt?version=2']
+     * @param {function} [fCallback=function() {}]
+     */
+    UpdateToVersion: function(webDavSession, sFolderAbsolutePath, sVersionHref, fCallback) {
+        webDavSession.OpenFileAsync(sFolderAbsolutePath, null, function(oFileAsyncResult) {
+
+            /** @typedef {ITHit.WebDAV.Client.File} oFile */
+            var oFile = oFileAsyncResult.Result;
+
+            oFile.UpdateToVersionAsync(sVersionHref, function(oAsyncResult) {
+
+                if (oAsyncResult.Result === true) {
+                    console.log('File `' + oFile.DisplayName + '` successfully updated to version `' + sVersionHref + '`');
+                }
+
+                fCallback(oAsyncResult);
+            });
+        });
+    }
+
+});
+
+QUnitRunner.test('Update and delete versions', function (test) {
+    QUnit.stop();
+    Helper.Create([
+        'Versions/man_ver.txt'
+    ], function() {
+        QUnit.start();
+
+        QUnit.stop();
+        webDavSession.OpenItemAsync(Helper.GetAbsolutePath('Versions/man_ver.txt'), null, function(oAsyncResult) {
+            QUnit.start();
+
+            /** @typedef {ITHit.WebDAV.Client.File} oFile */
+            var oFile = oAsyncResult.Result;
+
+            QUnit.stop();
+            Helper.CheckVersionsSupported(oFile, function(bIsVersionSupported) {
+                QUnit.start();
+
+                if (!bIsVersionSupported) {
+                    ITHitTests.skip(test, 'Server does not support versions.');
+                    return;
+                }
+
+                QUnit.stop();
+                oFile.GetVersionsAsync(function(oAsyncResult) {
+                    QUnit.start();
+
+                    var oVersion = oAsyncResult.Result[0];
+                    var iPrevLength = oAsyncResult.Result.length;
+
+                    QUnit.stop();
+                    ITHit.WebDAV.Client.Tests.Versions.ManageVersions.UpdateToThis(webDavSession, Helper.GetAbsolutePath('Versions/man_ver.txt'), function(oAsyncResult) {
+                        QUnit.start();
+
+                        test.strictEqual(oAsyncResult.IsSuccess, true, 'Check success of update to version request');
+
+                        QUnit.stop();
+                        ITHit.WebDAV.Client.Tests.Versions.ManageVersions.UpdateToVersion(webDavSession, Helper.GetAbsolutePath('Versions/man_ver.txt'), oVersion.Href, function(oAsyncResult) {
+                            QUnit.start();
+
+                            test.strictEqual(oAsyncResult.IsSuccess, true, 'Check success of update to version request (2)');
+
+                            QUnit.stop();
+                            oFile.GetVersionsAsync(function(oAsyncResult) {
+                                QUnit.start();
+
+                                test.strictEqual(oAsyncResult.Result.length, iPrevLength + 2, 'Check versions count');
+
+                                QUnit.stop();
+                                oVersion.DeleteAsync(function(oAsyncResult) {
+                                    QUnit.start();
+
+                                    test.strictEqual(oAsyncResult.IsSuccess, true, 'Check success of delete version request');
+
+                                    QUnit.stop();
+                                    oFile.GetVersionsAsync(function(oAsyncResult) {
+                                        QUnit.start();
+
+                                        test.strictEqual(oAsyncResult.Result.length, iPrevLength + 1, 'Check versions count');
+                                    });
+                                });
+                            });
+                        });
+                    });
+                });
+            });
+        });
+    });
+});
+
+QUnitRunner.test('Update version by write content', function (test) {
+    QUnit.stop();
+    Helper.Create([
+        'Versions/upd_wr.txt'
+    ], function() {
+        QUnit.start();
+
+        QUnit.stop();
+        webDavSession.OpenFileAsync(Helper.GetAbsolutePath('Versions/upd_wr.txt'), null, function(oAsyncResult) {
+            QUnit.start();
+
+            /** @typedef {ITHit.WebDAV.Client.File} oFile */
+            var oFile = oAsyncResult.Result;
+
+            QUnit.stop();
+            Helper.CheckVersionsSupported(oFile, function(bIsVersionSupported) {
+                QUnit.start();
+
+                if (!bIsVersionSupported) {
+                    ITHitTests.skip(test, 'Server does not support versions.');
+                    return;
+                }
+
+                QUnit.stop();
+                oFile.GetVersionsAsync(function(oAsyncResult) {
+                    var iPrevLength = oAsyncResult.Result.length;
+                    oFile.WriteContentAsync('test', null, null, function() {
+                        oFile.GetVersionsAsync(function(oAsyncResult) {
+                            QUnit.start();
+
+                            var iNowLength = oAsyncResult.Result.length;
+                            var oNewVersion = oAsyncResult.Result[oAsyncResult.Result.length - 1];
+
+                            test.strictEqual(iPrevLength, iNowLength - 1, 'Check versions count');
+                            test.strictEqual(oFile.ContentLength, 6, 'Check file v1 content length');
+                            test.strictEqual(oNewVersion.ContentLength, 4, 'Check file v2 content length');
+                        });
+                    });
+                });
+            });
+        });
+    });
+});

package/Tests/Versions/PutUnderVersion.js

@@ -0,0 +1,98 @@
+/**
+ * @typedef {ITHit.WebDAV.Client.WebDavSession} webDavSession
+ */
+
+QUnit.module('Versions.PutUnderVersion');
+
+/**
+ * @class ITHit.WebDAV.Client.Tests.Versions.PutUnderVersion
+ */
+ITHit.DefineClass('ITHit.WebDAV.Client.Tests.Versions.PutUnderVersion', null, {}, /** @lends ITHit.WebDAV.Client.Tests.Versions.PutUnderVersion */{
+
+    /**
+     * @param {ITHit.WebDAV.Client.WebDavSession} [webDavSession=new ITHit.WebDAV.Client.WebDavSession()]
+     * @param {string} [sFileAbsolutePath='http://localhost:87654/myfile.txt']
+     * @param {function} [fCallback=function() {}]
+     */
+    EnableVersion: function(webDavSession, sFileAbsolutePath, fCallback) {
+        webDavSession.OpenFileAsync(sFileAbsolutePath, null, function(oFileAsyncResult) {
+
+            /** @typedef {ITHit.WebDAV.Client.File} oFile */
+            var oFile = oFileAsyncResult.Result;
+
+            // Enable versioning
+            oFile.PutUnderVersionControlAsync(true, null, function(oAsyncResult) {
+
+                if (oAsyncResult.IsSuccess) {
+                    console.log('Versioning for file `' + oFile.DisplayName + '` is enabled.');
+                }
+
+                fCallback(oAsyncResult);
+            });
+        });
+    }
+
+});
+
+QUnitRunner.test('Enable and disable versioning', function (test) {
+    QUnit.stop();
+    Helper.Create([
+        'Versions/putunderver.txt'
+    ], function() {
+        QUnit.start();
+
+        QUnit.stop();
+        webDavSession.OpenItemAsync(Helper.GetAbsolutePath('Versions/putunderver.txt'), null, function(oAsyncResult) {
+            QUnit.start();
+
+            /** @typedef {ITHit.WebDAV.Client.File} oFile */
+            var oFile = oAsyncResult.Result;
+
+            QUnit.stop();
+            Helper.CheckVersionsSupported(oFile, function(bIsVersionSupported) {
+                QUnit.start();
+
+                if (!bIsVersionSupported) {
+                    ITHitTests.skip(test, 'Server does not support versions.');
+                    return;
+                }
+
+                test.strictEqual(oFile.VersionControlled, true, 'Check VersionControlled is true');
+
+                QUnit.stop();
+                oFile.PutUnderVersionControlAsync(false, null, function(oAsyncResult) {
+                    QUnit.start();
+
+                    test.strictEqual(oAsyncResult.IsSuccess, true, 'Check success of version control request (set false)');
+
+                    QUnit.stop();
+                    webDavSession.OpenItemAsync(Helper.GetAbsolutePath('Versions/putunderver.txt'), null, function(oAsyncResult) {
+                        QUnit.start();
+
+                        /** @typedef {ITHit.WebDAV.Client.HierarchyItem} oFile */
+                        oFile = oAsyncResult.Result;
+
+                        test.strictEqual(oFile.VersionControlled, false, 'Check VersionControlled is false');
+
+                        QUnit.stop();
+                        ITHit.WebDAV.Client.Tests.Versions.PutUnderVersion.EnableVersion(webDavSession, Helper.GetAbsolutePath('Versions/putunderver.txt'), function(oAsyncResult) {
+                            QUnit.start();
+
+                            test.strictEqual(oAsyncResult.IsSuccess, true, 'Check success of version control request (set true)');
+
+                            QUnit.stop();
+                            webDavSession.OpenItemAsync(Helper.GetAbsolutePath('Versions/putunderver.txt'), null, function(oAsyncResult) {
+                                QUnit.start();
+
+                                /** @typedef {ITHit.WebDAV.Client.HierarchyItem} oFile */
+                                oFile = oAsyncResult.Result;
+
+                                test.strictEqual(oFile.VersionControlled, true, 'Check VersionControlled is true');
+                            });
+                        });
+                    });
+                });
+            });
+        });
+    });
+});

package/Tests/Versions/ReadContent.js

@@ -0,0 +1,82 @@
+/**
+ * @typedef {ITHit.WebDAV.Client.WebDavSession} webDavSession
+ */
+
+QUnit.module('Versions.ReadContent');
+
+/**
+ * @class ITHit.WebDAV.Client.Tests.Versions.ReadContent
+ */
+ITHit.DefineClass('ITHit.WebDAV.Client.Tests.Versions.ReadContent', null, {}, /** @lends ITHit.WebDAV.Client.Tests.Versions.ReadContent */{
+
+    /**
+     * @param {ITHit.WebDAV.Client.WebDavSession} [webDavSession=new ITHit.WebDAV.Client.WebDavSession()]
+     * @param {string} [sFolderAbsolutePath='http://localhost:87654/myfile.txt']
+     * @param {function} [fCallback=function() {}]
+     */
+    ReadContent: function(webDavSession, sFolderAbsolutePath, fCallback) {
+        webDavSession.OpenFileAsync(sFolderAbsolutePath, null, function(oFileAsyncResult) {
+
+            /** @typedef {ITHit.WebDAV.Client.File} oFile */
+            var oFile = oFileAsyncResult.Result;
+
+            oFile.GetVersionsAsync(function(oVersionsAsyncResult) {
+
+                /** @typedef {ITHit.WebDAV.Client.Version[]} aVersions */
+                var aVersions = oVersionsAsyncResult.Result;
+
+                /** @typedef {ITHit.WebDAV.Client.Version} oVersion */
+                var oVersion = aVersions[0];
+
+                oVersion.ReadContentAsync(null, null, function(oAsyncResult) {
+
+                    /** @typedef {String} sContent */
+                    var sContent = oAsyncResult.Result;
+
+                    console.log('Version ' + oVersion.VersionName + ', content:' + sContent);
+
+                    fCallback(oAsyncResult);
+                });
+            });
+        });
+    }
+
+});
+
+QUnitRunner.test('Read version content', function (test) {
+    QUnit.stop();
+    Helper.Create([
+        'Versions/ver_read.txt'
+    ], function() {
+        QUnit.start();
+
+        QUnit.stop();
+        webDavSession.OpenFileAsync(Helper.GetAbsolutePath('Versions/ver_read.txt'), null, function(oAsyncResult) {
+            QUnit.start();
+
+            /** @typedef {ITHit.WebDAV.Client.File} oFile */
+            var oFile = oAsyncResult.Result;
+
+            QUnit.stop();
+            Helper.CheckVersionsSupported(oFile, function(bIsVersionSupported) {
+                QUnit.start();
+
+                if (!bIsVersionSupported) {
+                    ITHitTests.skip(test, 'Server does not support versions.');
+                    return;
+                }
+
+                test.strictEqual(oAsyncResult.IsSuccess, true, 'Check success of open item request');
+                test.strictEqual(oFile instanceof ITHit.WebDAV.Client.HierarchyItem, true, 'Check result is instance of HierarchyItem');
+
+                QUnit.stop();
+                ITHit.WebDAV.Client.Tests.Versions.ReadContent.ReadContent(webDavSession, Helper.GetAbsolutePath('Versions/ver_read.txt'), function(oAsyncResult) {
+                    QUnit.start();
+
+                    test.strictEqual(oAsyncResult.IsSuccess, true, 'Check success of read version request');
+                    test.strictEqual(oAsyncResult.Result, 'test..', 'Check version content');
+                });
+            });
+        });
+    });
+});

package/Tests/WebDavSession/Events.js

@@ -0,0 +1,125 @@
+/**
+ * @typedef {ITHit.WebDAV.Client.WebDavSession} webDavSession
+ */
+
+QUnit.module('WebDavSession.Events');
+
+/**
+ * @class ITHit.WebDAV.Client.Tests.WebDavSession.Events
+ */
+ITHit.DefineClass('ITHit.WebDAV.Client.Tests.WebDavSession.Events', null, {}, /** @lends ITHit.WebDAV.Client.Tests.WebDavSession.Events */{
+
+    /**
+     * @param {ITHit.WebDAV.Client.WebDavSession} [webDavSession=new ITHit.WebDAV.Client.WebDavSession()]
+     * @param {function} [fCallback=function() {}]
+     */
+    BeforeRequestSend: function(webDavSession, fCallback) {
+        webDavSession.AddListener('OnBeforeRequestSend', function(oEvent) {
+
+            // Add new header
+            //oEvent.Headers['My-Header'] = oEvent.Method;
+
+            // Show request info
+            console.log(oEvent.Method + ' ' + oEvent.Href);
+            for (var sKey in oEvent.Headers) {
+                if (oEvent.Headers.hasOwnProperty(sKey)) {
+                    console.log(sKey + ': ' + oEvent.Headers[sKey]);
+                }
+            }
+
+            // Show request body
+            console.log(oEvent.Body);
+
+            fCallback(oEvent);
+        });
+    },
+
+    /**
+     * @param {ITHit.WebDAV.Client.WebDavSession} [webDavSession=new ITHit.WebDAV.Client.WebDavSession()]
+     * @param {function} [fCallback=function() {}]
+     */
+    Response: function(webDavSession, fCallback) {
+        webDavSession.AddListener('OnResponse', function(oEvent) {
+
+            // Show HTTP status and description
+            console.log(oEvent.Status + ' ' + oEvent.StatusDescription);
+
+            // Show headers
+            for (var sKey in oEvent.Headers) {
+                if (oEvent.Headers.hasOwnProperty(sKey)) {
+                    console.log(sKey + ': ' + oEvent.Headers[sKey]);
+                }
+            }
+
+            // Show response body
+            console.log(oEvent.BodyText);
+
+            fCallback(oEvent);
+        });
+    }
+
+});
+
+QUnitRunner.test('Subscribe on WebDavSession events: OnBeforeRequestSend, OnResponse', function (test) {
+    QUnit.stop();
+    Helper.Create([
+        'WebDavSession/event.txt'
+    ], function() {
+        QUnit.start();
+
+        var oRequestData = null;
+        var oResponseData = null;
+
+        ITHit.WebDAV.Client.Tests.WebDavSession.Events.BeforeRequestSend(webDavSession, function(oEvent) {
+            oRequestData = oEvent;
+        });
+        ITHit.WebDAV.Client.Tests.WebDavSession.Events.Response(webDavSession, function(oEvent) {
+            oResponseData = oEvent;
+        });
+
+        QUnit.stop();
+        webDavSession.OpenFileAsync(Helper.GetAbsolutePath('WebDavSession/event.txt'), null, function(oAsyncResult) {
+            QUnit.start();
+
+
+            test.strictEqual(oRequestData.Method, 'PROPFIND', 'Check method in request event data');
+            test.strictEqual(oRequestData.Href.replace(/\?.*$/, ''), Helper.GetAbsolutePath('WebDavSession/event.txt'), 'Check href in request event data');
+            test.strictEqual(oRequestData.Headers.Depth, 0, 'Check header depth in request event data');
+            test.strictEqual(oRequestData.Headers['Content-Type'].replace(/; ?/g, '; '), 'text/xml; charset="utf-8"', 'Check content type header in request event data');
+
+
+			var xml = new ITHit.XMLDoc();
+			xml.load(oRequestData.Body);
+			var nodes = xml.childNodes()[0].childNodes()[0].childNodes();
+			var propNames = [];
+			for (var i = 0, l = nodes.length; i < l; i++) {
+				propNames.push(nodes[i].nodeName());
+			}
+
+            test.strictEqual(propNames.join(), [
+				"resourcetype",
+				"displayname",
+				"creationdate",
+				"getlastmodified",
+				"getcontenttype",
+				"getcontentlength",
+				"supportedlock",
+				"lockdiscovery",
+				"quota-available-bytes",
+				"quota-used-bytes",
+				"checked-in",
+				"checked-out"
+			].join(), 'Check body in request event data');
+
+            test.strictEqual(oResponseData.Status, ITHit.WebDAV.Client.HttpStatus.MultiStatus.Code, 'Check status in response event data');
+            test.strictEqual(oResponseData.StatusDescription, ITHit.WebDAV.Client.HttpStatus.MultiStatus.Description, 'Check status description in response event data');
+            for (var key in oResponseData.Headers) {
+                if (key.toLowerCase() == 'content-type') {
+                    test.strictEqual(oResponseData.Headers[key].replace(/; ?/g, '; '), 'application/xml; charset=utf-8', 'Check content type header in response event data');
+                    break;
+                }
+            }
+            test.strictEqual(oResponseData.BodyText.indexOf('event.txt') !== -1, true, 'Check body text in response event data');
+        });
+    });
+});

package/Tests/index.html

@@ -0,0 +1,9 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <script src="ITHitTests.js" type="text/javascript"></script>
+    <script src="../ITHitWebDAVClient.js" type="text/javascript"></script>
+</head>
+<body>
+</body>
+</html>