From f120846e291bf83244831770c5f25b730fa8ba90 Mon Sep 17 00:00:00 2001 From: Vincent Petry Date: Mon, 13 Jul 2015 17:31:47 +0200 Subject: [PATCH] Added OC.Files.Client Webdav-based files client --- buildjsdocs.sh | 2 +- core/js/files/client.js | 673 ++++++++++++++++++++++ core/js/files/fileinfo.js | 143 +++++ core/js/js.js | 1 - core/js/tests/specHelper.js | 1 + core/js/tests/specs/files/clientSpec.js | 712 ++++++++++++++++++++++++ tests/karma.config.js | 6 +- 7 files changed, 1533 insertions(+), 5 deletions(-) create mode 100644 core/js/files/client.js create mode 100644 core/js/files/fileinfo.js create mode 100644 core/js/tests/specs/files/clientSpec.js diff --git a/buildjsdocs.sh b/buildjsdocs.sh index 90562558f6..57eefb29fd 100755 --- a/buildjsdocs.sh +++ b/buildjsdocs.sh @@ -11,7 +11,7 @@ NPM="$(which npm 2>/dev/null)" PREFIX="build" OUTPUT_DIR="build/jsdocs" -JS_FILES="core/js/*.js apps/*/js/*.js" +JS_FILES="core/js/*.js core/js/**/*.js apps/*/js/*.js" if test -z "$NPM" then diff --git a/core/js/files/client.js b/core/js/files/client.js new file mode 100644 index 0000000000..9bb7bb999f --- /dev/null +++ b/core/js/files/client.js @@ -0,0 +1,673 @@ +/* + * Copyright (c) 2015 + * + * This file is licensed under the Affero General Public License version 3 + * or later. + * + * See the COPYING-README file. + * + */ + +/* global dav */ + +(function(OC, FileInfo) { + /** + * @class OC.Files.Client + * @classdesc Client to access files on the server + * + * @param {Object} options + * @param {String} options.host host name + * @param {int} [options.port] port + * @param {boolean} [options.useHTTPS] whether to use https + * @param {String} [options.root] root path + * @param {String} [options.userName] user name + * @param {String} [options.password] password + * + * @since 8.2 + */ + var Client = function(options) { + this._root = options.root; + if (this._root.charAt(this._root.length - 1) === '/') { + this._root = this._root.substr(0, this._root.length - 1); + } + + if (!options.port) { + // workaround in case port is null or empty + options.port = undefined; + } + var url = ''; + var port = ''; + if (options.useHTTPS) { + url += 'https://'; + if (options.port && options.port !== 443) { + port = ':' + options.port; + } + } else { + url += 'http://'; + if (options.port && options.port !== 80) { + port = ':' + options.port; + } + } + var credentials = ''; + if (options.userName) { + credentials += encodeURIComponent(options.userName); + } + if (options.password) { + credentials += ':' + encodeURIComponent(options.password); + } + if (credentials.length > 0) { + url += credentials + '@'; + } + + url += options.host + port + this._root; + this._defaultHeaders = options.defaultHeaders || {'X-Requested-With': 'XMLHttpRequest'}; + this._baseUrl = url; + this._client = new dav.Client({ + baseUrl: this._baseUrl, + xmlNamespaces: { + 'DAV:': 'd', + 'http://owncloud.org/ns': 'oc' + } + }); + this._client.xhrProvider = _.bind(this._xhrProvider, this); + }; + + Client.NS_OWNCLOUD = 'http://owncloud.org/ns'; + Client.NS_DAV = 'DAV:'; + Client._PROPFIND_PROPERTIES = [ + /** + * Modified time + */ + [Client.NS_DAV, 'getlastmodified'], + /** + * Etag + */ + [Client.NS_DAV, 'getetag'], + /** + * Mime type + */ + [Client.NS_DAV, 'getcontenttype'], + /** + * Resource type "collection" for folders, empty otherwise + */ + [Client.NS_DAV, 'resourcetype'], + /** + * Compound file id, contains fileid + server instance id + */ + [Client.NS_OWNCLOUD, 'id'], + /** + * Letter-coded permissions + */ + [Client.NS_OWNCLOUD, 'permissions'], + //[Client.NS_OWNCLOUD, 'downloadURL'], + /** + * Folder sizes + */ + [Client.NS_OWNCLOUD, 'size'], + /** + * File sizes + */ + [Client.NS_DAV, 'getcontentlength'] + ]; + + /** + * @memberof OC.Files + */ + Client.prototype = { + + /** + * Root path of the Webdav endpoint + * + * @type string + */ + _root: null, + + /** + * Client from the library + * + * @type nl.sara.webdav.Client + */ + _client: null, + + /** + * Returns the configured XHR provider for davclient + * @return {XMLHttpRequest} + */ + _xhrProvider: function() { + var headers = this._defaultHeaders; + var xhr = new XMLHttpRequest(); + var oldOpen = xhr.open; + // override open() method to add headers + xhr.open = function() { + var result = oldOpen.apply(this, arguments); + _.each(headers, function(value, key) { + xhr.setRequestHeader(key, value); + }); + return result; + }; + return xhr; + }, + + /** + * Prepends the base url to the given path sections + * + * @param {...String} path sections + * + * @return {String} base url + joined path, any leading or trailing slash + * will be kept + */ + _buildUrl: function() { + var path = this._buildPath.apply(this, arguments); + if (path.charAt([path.length - 1]) === '/') { + path = path.substr(0, path.length - 1); + } + if (path.charAt(0) === '/') { + path = path.substr(1); + } + return this._baseUrl + '/' + path; + }, + + /** + * Append the path to the root and also encode path + * sections + * + * @param {...String} path sections + * + * @return {String} joined path, any leading or trailing slash + * will be kept + */ + _buildPath: function() { + var path = OC.joinPaths.apply(this, arguments); + var sections = path.split('/'); + var i; + for (i = 0; i < sections.length; i++) { + sections[i] = encodeURIComponent(sections[i]); + } + path = sections.join('/'); + return path; + }, + + /** + * Parse headers string into a map + * + * @param {string} headersString headers list as string + * + * @return {Object.} map of header name to header contents + */ + _parseHeaders: function(headersString) { + var headerRows = headersString.split('\n'); + var headers = {}; + for (var i = 0; i < headerRows.length; i++) { + var sepPos = headerRows[i].indexOf(':'); + if (sepPos < 0) { + continue; + } + + var headerName = headerRows[i].substr(0, sepPos); + var headerValue = headerRows[i].substr(sepPos + 2); + + if (!headers[headerName]) { + // make it an array + headers[headerName] = []; + } + + headers[headerName].push(headerValue); + } + return headers; + }, + + /** + * Parses the compound file id + * + * @param {string} compoundFileId compound file id as returned by the server + * + * @return {int} local file id, stripped of the instance id + */ + _parseFileId: function(compoundFileId) { + if (!compoundFileId || compoundFileId.length < 8) { + return null; + } + return parseInt(compoundFileId.substr(0, 8), 10); + }, + + /** + * Parses the etag response which is in double quotes. + * + * @param {string} etag etag value in double quotes + * + * @return {string} etag without double quotes + */ + _parseEtag: function(etag) { + if (etag.charAt(0) === '"') { + return etag.split('"')[1]; + } + return etag; + }, + + /** + * Parse Webdav result + * + * @param {Object} response XML object + * + * @return {Array.} array of file info + */ + _parseFileInfo: function(response) { + var path = response.href; + if (path.substr(0, this._root.length) === this._root) { + path = path.substr(this._root.length); + } + + if (path.charAt(path.length - 1) === '/') { + path = path.substr(0, path.length - 1); + } + + path = '/' + decodeURIComponent(path); + + if (response.propStat.length === 1 && response.propStat[0].status !== 200) { + return null; + } + + var props = response.propStat[0].properties; + + var data = { + id: this._parseFileId(props['{' + Client.NS_OWNCLOUD + '}id']), + path: OC.dirname(path) || '/', + name: OC.basename(path), + mtime: new Date(props['{' + Client.NS_DAV + '}getlastmodified']), + _props: props + }; + + var etagProp = props['{' + Client.NS_DAV + '}getetag']; + if (!_.isUndefined(etagProp)) { + data.etag = this._parseEtag(etagProp); + } + + var sizeProp = props['{' + Client.NS_DAV + '}getcontentlength']; + if (!_.isUndefined(sizeProp)) { + data.size = parseInt(sizeProp, 10); + } + + sizeProp = props['{' + Client.NS_OWNCLOUD + '}size']; + if (!_.isUndefined(sizeProp)) { + data.size = parseInt(sizeProp, 10); + } + + var contentType = props['{' + Client.NS_DAV + '}getcontenttype']; + if (!_.isUndefined(contentType)) { + data.mimetype = contentType; + } + + var resType = props['{' + Client.NS_DAV + '}resourcetype']; + var isFile = true; + if (!data.mimetype && resType) { + var xmlvalue = resType[0]; + if (xmlvalue.namespaceURI === Client.NS_DAV && xmlvalue.nodeName.split(':')[1] === 'collection') { + data.mimetype = 'httpd/unix-directory'; + isFile = false; + } + } + + data.permissions = OC.PERMISSION_READ; + var permissionProp = props['{' + Client.NS_OWNCLOUD + '}permissions']; + if (!_.isUndefined(permissionProp)) { + var permString = permissionProp || ''; + data.mountType = null; + for (var i = 0; i < permString.length; i++) { + var c = permString.charAt(i); + switch (c) { + // FIXME: twisted permissions + case 'C': + case 'K': + data.permissions |= OC.PERMISSION_CREATE; + if (!isFile) { + data.permissions |= OC.PERMISSION_UPDATE; + } + break; + case 'W': + if (isFile) { + // also add create permissions + data.permissions |= OC.PERMISSION_CREATE; + } + data.permissions |= OC.PERMISSION_UPDATE; + break; + case 'D': + data.permissions |= OC.PERMISSION_DELETE; + break; + case 'R': + data.permissions |= OC.PERMISSION_SHARE; + break; + case 'M': + if (!data.mountType) { + // TODO: how to identify external-root ? + data.mountType = 'external'; + } + break; + case 'S': + // TODO: how to identify shared-root ? + data.mountType = 'shared'; + break; + } + } + } + + return new FileInfo(data); + }, + + /** + * Parse Webdav multistatus + * + * @param {Array} responses + */ + _parseResult: function(responses) { + var self = this; + return _.map(responses, function(response) { + return self._parseFileInfo(response); + }); + }, + + /** + * Returns whether the given status code means success + * + * @param {int} status status code + * + * @return true if status code is between 200 and 299 included + */ + _isSuccessStatus: function(status) { + return status >= 200 && status <= 299; + }, + + /** + * Returns the default PROPFIND properties to use during a call. + * + * @return {Array.} array of properties + */ + _getPropfindProperties: function() { + if (!this._propfindProperties) { + this._propfindProperties = _.map(Client._PROPFIND_PROPERTIES, function(propDef) { + return '{' + propDef[0] + '}' + propDef[1]; + }); + } + return this._propfindProperties; + }, + + /** + * Lists the contents of a directory + * + * @param {String} path path to retrieve + * @param {Object} [options] options + * @param {boolean} [options.includeParent=false] set to true to keep + * the parent folder in the result list + * + * @return {Promise} promise + */ + getFolderContents: function(path, options) { + if (!path) { + path = ''; + } + var self = this; + var deferred = $.Deferred(); + var promise = deferred.promise(); + + // TODO: headers + this._client.propFind( + this._buildUrl(path), + this._getPropfindProperties(), + 1 + ).then(function(result) { + if (self._isSuccessStatus(result.status)) { + var results = self._parseResult(result.body); + if (!options || !options.includeParent) { + // remove root dir, the first entry + results.shift(); + } + deferred.resolve(result.status, results); + } else { + deferred.reject(result.status); + } + }); + return promise; + }, + + /** + * Returns the file info of a given path. + * + * @param {String} path path + * @param {Array} [properties] list of webdav properties to + * retrieve + * + * @return {Promise} promise + */ + getFileInfo: function(path) { + if (!path) { + path = ''; + } + var self = this; + var deferred = $.Deferred(); + var promise = deferred.promise(); + + // TODO: headers + this._client.propFind( + this._buildUrl(path), + this._getPropfindProperties(), + 0 + ).then( + function(result) { + if (self._isSuccessStatus(result.status)) { + deferred.resolve(result.status, self._parseResult([result.body])[0]); + } else { + deferred.reject(result.status); + } + } + ); + return promise; + }, + + /** + * Returns the contents of the given file. + * + * @param {String} path path to file + * + * @return {Promise} + */ + getFileContents: function(path) { + if (!path) { + throw 'Missing argument "path"'; + } + var self = this; + var deferred = $.Deferred(); + var promise = deferred.promise(); + + this._client.request( + 'GET', + this._buildUrl(path), + this._defaultHeaders + ).then( + function(result) { + if (self._isSuccessStatus(result.status)) { + deferred.resolve(result.status, result.body); + } else { + deferred.reject(result.status); + } + } + ); + return promise; + }, + + /** + * Puts the given data into the given file. + * + * @param {String} path path to file + * @param {String} body file body + * @param {Object} [options] + * @param {String} [options.contentType='text/plain'] content type + * @param {bool} [options.overwrite=true] whether to overwrite an existing file + * + * @return {Promise} + */ + putFileContents: function(path, body, options) { + if (!path) { + throw 'Missing argument "path"'; + } + var self = this; + var deferred = $.Deferred(); + var promise = deferred.promise(); + options = options || {}; + var headers = _.extend({}, this._defaultHeaders); + var contentType = 'text/plain'; + if (options.contentType) { + contentType = options.contentType; + } + + headers['Content-Type'] = contentType; + + if (_.isUndefined(options.overwrite) || options.overwrite) { + // will trigger 412 precondition failed if a file already exists + headers['If-None-Match'] = '*'; + } + + this._client.request( + 'PUT', + this._buildUrl(path), + headers, + body || '' + ).then( + function(result) { + if (self._isSuccessStatus(result.status)) { + deferred.resolve(result.status); + } else { + deferred.reject(result.status); + } + } + ); + return promise; + }, + + _simpleCall: function(method, path) { + if (!path) { + throw 'Missing argument "path"'; + } + + var self = this; + var deferred = $.Deferred(); + var promise = deferred.promise(); + + this._client.request( + method, + this._buildUrl(path), + this._defaultHeaders + ).then( + function(result) { + if (self._isSuccessStatus(result.status)) { + deferred.resolve(result.status); + } else { + deferred.reject(result.status); + } + } + ); + return promise; + }, + + /** + * Creates a directory + * + * @param {String} path path to create + * + * @return {Promise} + */ + createDirectory: function(path) { + return this._simpleCall('MKCOL', path); + }, + + /** + * Deletes a file or directory + * + * @param {String} path path to delete + * + * @return {Promise} + */ + remove: function(path) { + return this._simpleCall('DELETE', path); + }, + + /** + * Moves path to another path + * + * @param {String} path path to move + * @param {String} destinationPath destination path + * @param {boolean} [allowOverwrite=false] true to allow overwriting, + * false otherwise + * + * @return {Promise} promise + */ + move: function(path, destinationPath, allowOverwrite) { + if (!path) { + throw 'Missing argument "path"'; + } + if (!destinationPath) { + throw 'Missing argument "destinationPath"'; + } + + var self = this; + var deferred = $.Deferred(); + var promise = deferred.promise(); + var headers = + _.extend({ + 'Destination' : this._buildUrl(destinationPath) + }, this._defaultHeaders); + + if (!allowOverwrite) { + headers['Overwrite'] = 'F'; + } + + this._client.request( + 'MOVE', + this._buildUrl(path), + headers + ).then( + function(response) { + if (self._isSuccessStatus(response.status)) { + deferred.resolve(response.status); + } else { + deferred.reject(response.status); + } + } + ); + return promise; + } + + }; + + if (!OC.Files) { + /** + * @namespace OC.Files + * + * @since 8.2 + */ + OC.Files = {}; + } + + /** + * Returns the default instance of the files client + * + * @return {OC.Files.Client} default client + * + * @since 8.2 + */ + OC.Files.getClient = function() { + if (OC.Files._defaultClient) { + return OC.Files._defaultClient; + } + + var client = new OC.Files.Client({ + host: OC.getHost(), + port: OC.getPort(), + root: OC.linkToRemoteBase('webdav'), + useHTTPS: OC.getProtocol() === 'https' + }); + OC.Files._defaultClient = client; + return client; + }; + + OC.Files.Client = Client; +})(OC, OC.Files.FileInfo); + diff --git a/core/js/files/fileinfo.js b/core/js/files/fileinfo.js new file mode 100644 index 0000000000..95af07b799 --- /dev/null +++ b/core/js/files/fileinfo.js @@ -0,0 +1,143 @@ +/* + * Copyright (c) 2015 + * + * This file is licensed under the Affero General Public License version 3 + * or later. + * + * See the COPYING-README file. + * + */ + +(function(OC) { + + /** + * @class OC.Files.FileInfo + * @classdesc File information + * + * @param {Object} data file data, see attributes for details + * + * @since 8.2 + */ + var FileInfo = function(data) { + if (!_.isUndefined(data.id)) { + this.id = parseInt(data.id, 10); + } + + // TODO: normalize path + this.path = data.path || ''; + this.name = data.name; + + this.mtime = data.mtime; + this.etag = data.etag; + this.permissions = data.permissions; + this.size = data.size; + this.mimetype = data.mimetype || 'application/octet-stream'; + this.mountType = data.mountType; + this.icon = data.icon; + this._props = data._props; + + if (data.type) { + this.type = data.type; + } else if (this.mimetype === 'httpd/unix-directory') { + this.type = 'dir'; + } else { + this.type = 'file'; + } + + if (!this.mimetype) { + if (this.type === 'dir') { + this.mimetype = 'httpd/unix-directory'; + } else { + this.mimetype = 'application/octet-stream'; + } + } + }; + + /** + * @memberof OC.Files + */ + FileInfo.prototype = { + /** + * File id + * + * @type int + */ + id: null, + + /** + * File name + * + * @type String + */ + name: null, + + /** + * Path leading to the file, without the file name, + * and with a leading slash. + * + * @type String + */ + path: null, + + /** + * Mime type + * + * @type String + */ + mimetype: null, + + /** + * Icon URL. + * + * Can be used to override the mime type icon. + * + * @type String + */ + icon: null, + + /** + * File type. 'file' for files, 'dir' for directories. + * + * @type String + * @deprecated rely on mimetype instead + */ + type: 'file', + + /** + * Permissions. + * + * @see OC#PERMISSION_ALL for permissions + * @type int + */ + permissions: null, + + /** + * Modification time + * + * @type int + */ + mtime: null, + + /** + * Etag + * + * @type String + */ + etag: null, + + /** + * Mount type. + * + * One of null, "external-root", "shared" or "shared-root" + * + * @type string + */ + mountType: null + }; + + if (!OC.Files) { + OC.Files = {}; + } + OC.Files.FileInfo = FileInfo; +})(OC); + diff --git a/core/js/js.js b/core/js/js.js index 57c9871233..ce552bb8ea 100644 --- a/core/js/js.js +++ b/core/js/js.js @@ -1428,7 +1428,6 @@ function initCore() { $('body').delegate('#app-content', 'apprendered appresized', adjustControlsWidth); } - } $(document).ready(initCore); diff --git a/core/js/tests/specHelper.js b/core/js/tests/specHelper.js index cd387d76ce..f09a7054c9 100644 --- a/core/js/tests/specHelper.js +++ b/core/js/tests/specHelper.js @@ -86,6 +86,7 @@ window.firstDay = 0; // setup dummy webroots /* jshint camelcase: false */ window.oc_debug = true; +// FIXME: oc_webroot is supposed to be only the path!!! window.oc_webroot = location.href + '/'; window.oc_appswebroots = { "files": window.oc_webroot + '/apps/files/' diff --git a/core/js/tests/specs/files/clientSpec.js b/core/js/tests/specs/files/clientSpec.js new file mode 100644 index 0000000000..67815d93f0 --- /dev/null +++ b/core/js/tests/specs/files/clientSpec.js @@ -0,0 +1,712 @@ +/** +* ownCloud +* +* @author Vincent Petry +* @copyright 2015 Vincent Petry +* +* This library is free software; you can redistribute it and/or +* modify it under the terms of the GNU AFFERO GENERAL PUBLIC LICENSE +* License as published by the Free Software Foundation; either +* version 3 of the License, or any later version. +* +* This library is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU AFFERO GENERAL PUBLIC LICENSE for more details. +* +* You should have received a copy of the GNU Affero General Public +* License along with this library. If not, see . +* +*/ + +describe('OC.Files.Client tests', function() { + var Client = OC.Files.Client; + var baseUrl; + var client; + + beforeEach(function() { + baseUrl = 'https://testhost:999/owncloud/remote.php/webdav/'; + + client = new Client({ + host: 'testhost', + port: 999, + root: '/owncloud/remote.php/webdav', + useHTTPS: true + }); + }); + afterEach(function() { + client = null; + }); + + /** + * Send an status response and check that the given + * promise gets its success handler called with the error + * status code + * + * @param {Promise} promise promise + * @param {int} status status to test + */ + function respondAndCheckStatus(promise, status) { + var successHandler = sinon.stub(); + var failHandler = sinon.stub(); + promise.done(successHandler); + promise.fail(failHandler); + + fakeServer.requests[0].respond( + status, + {'Content-Type': 'application/xml'}, + '' + ); + + promise.then(function() { + expect(successHandler.calledOnce).toEqual(true); + expect(successHandler.getCall(0).args[0]).toEqual(status); + + expect(failHandler.notCalled).toEqual(true); + }); + + return promise; + } + + /** + * Send an error response and check that the given + * promise gets its fail handler called with the error + * status code + * + * @param {Promise} promise promise object + * @param {int} status error status to test + */ + function respondAndCheckError(promise, status) { + var successHandler = sinon.stub(); + var failHandler = sinon.stub(); + promise.done(successHandler); + promise.fail(failHandler); + + fakeServer.requests[0].respond( + status, + {'Content-Type': 'application/xml'}, + '' + ); + + promise.then(function() { + expect(failHandler.calledOnce).toEqual(true); + expect(failHandler.calledWith(status)).toEqual(true); + + expect(successHandler.notCalled).toEqual(true); + + fulfill(); + }); + + return promise; + } + + /** + * Returns a list of request properties parsed from the given request body. + * + * @param {string} requestBody request XML + * + * @return {Array.} array of request properties in the format + * "{NS:}propname" + */ + function getRequestedProperties(requestBody) { + var doc = (new window.DOMParser()).parseFromString( + requestBody, + 'application/xml' + ); + var propRoots = doc.getElementsByTagNameNS('DAV:', 'prop'); + var propsList = propRoots.item(0).childNodes; + return _.map(propsList, function(propNode) { + return '{' + propNode.namespaceURI + '}' + propNode.localName; + }); + } + + function makePropBlock(props) { + var s = '\n'; + + _.each(props, function(value, key) { + s += '<' + key + '>' + value + '\n'; + }); + + return s + '\n'; + } + + function makeResponseBlock(href, props, failedProps) { + var s = '\n'; + s += '' + href + '\n'; + s += '\n'; + s += makePropBlock(props); + s += 'HTTP/1.1 200 OK'; + s += '\n'; + if (failedProps) { + s += '\n'; + _.each(failedProps, function(prop) { + s += '<' + prop + '/>\n'; + }); + s += 'HTTP/1.1 404 Not Found\n'; + s += '\n'; + } + return s + '\n'; + } + + describe('file listing', function() { + + var folderContentsXml = + '' + + '' + + makeResponseBlock( + '/owncloud/remote.php/webdav/path/to%20space/%E6%96%87%E4%BB%B6%E5%A4%B9/', + { + 'd:getlastmodified': 'Fri, 10 Jul 2015 10:00:05 GMT', + 'd:getetag': '"56cfcabd79abb"', + 'd:resourcetype': '', + 'oc:id': '00000011oc2d13a6a068', + 'oc:permissions': 'RDNVCK', + 'oc:size': 120 + }, + [ + 'd:getcontenttype', + 'd:getcontentlength' + ] + ) + + makeResponseBlock( + '/owncloud/remote.php/webdav/path/to%20space/%E6%96%87%E4%BB%B6%E5%A4%B9/One.txt', + { + 'd:getlastmodified': 'Fri, 10 Jul 2015 13:38:05 GMT', + 'd:getetag': '"559fcabd79a38"', + 'd:getcontenttype': 'text/plain', + 'd:getcontentlength': 250, + 'd:resourcetype': '', + 'oc:id': '00000051oc2d13a6a068', + 'oc:permissions': 'RDNVW' + }, + [ + 'oc:size', + ] + ) + + makeResponseBlock( + '/owncloud/remote.php/webdav/path/to%20space/%E6%96%87%E4%BB%B6%E5%A4%B9/sub', + { + 'd:getlastmodified': 'Fri, 10 Jul 2015 14:00:00 GMT', + 'd:getetag': '"66cfcabd79abb"', + 'd:resourcetype': '', + 'oc:id': '00000015oc2d13a6a068', + 'oc:permissions': 'RDNVCK', + 'oc:size': 100 + }, + [ + 'd:getcontenttype', + 'd:getcontentlength' + ] + ) + + ''; + + it('sends PROPFIND with explicit properties to get file list', function() { + client.getFolderContents('path/to space/文件夹'); + + expect(fakeServer.requests.length).toEqual(1); + expect(fakeServer.requests[0].method).toEqual('PROPFIND'); + expect(fakeServer.requests[0].url).toEqual(baseUrl + 'path/to%20space/%E6%96%87%E4%BB%B6%E5%A4%B9'); + expect(fakeServer.requests[0].requestHeaders.Depth).toEqual(1); + + var props = getRequestedProperties(fakeServer.requests[0].requestBody); + expect(props).toContain('{DAV:}getlastmodified'); + expect(props).toContain('{DAV:}getcontentlength'); + expect(props).toContain('{DAV:}getcontenttype'); + expect(props).toContain('{DAV:}getetag'); + expect(props).toContain('{DAV:}resourcetype'); + expect(props).toContain('{http://owncloud.org/ns}id'); + expect(props).toContain('{http://owncloud.org/ns}size'); + expect(props).toContain('{http://owncloud.org/ns}permissions'); + }); + it('sends PROPFIND to base url when empty path given', function() { + client.getFolderContents(''); + expect(fakeServer.requests.length).toEqual(1); + expect(fakeServer.requests[0].url).toEqual(baseUrl); + }); + it('sends PROPFIND to base url when root path given', function() { + client.getFolderContents('/'); + expect(fakeServer.requests.length).toEqual(1); + expect(fakeServer.requests[0].url).toEqual(baseUrl); + }); + it('parses the result list into a FileInfo array', function() { + var promise = client.getFolderContents('path/to space/文件夹'); + + expect(fakeServer.requests.length).toEqual(1); + + fakeServer.requests[0].respond( + 207, + {'Content-Type': 'application/xml'}, + folderContentsXml + ); + + promise.then(function(status, response) { + expect(status).toEqual(207); + expect(_.isArray(response)).toEqual(true); + + expect(response.length).toEqual(2); + + // file entry + var info = response[0]; + expect(info instanceof OC.Files.FileInfo).toEqual(true); + expect(info.id).toEqual(51); + expect(info.path).toEqual('/path/to space/文件夹'); + expect(info.name).toEqual('One.txt'); + expect(info.permissions).toEqual(31); + expect(info.size).toEqual(250); + expect(info.mtime.getTime()).toEqual(1436535485000); + expect(info.mimetype).toEqual('text/plain'); + expect(info.etag).toEqual('559fcabd79a38'); + + // sub entry + info = response[1]; + expect(info instanceof OC.Files.FileInfo).toEqual(true); + expect(info.id).toEqual(15); + expect(info.path).toEqual('/path/to space/文件夹'); + expect(info.name).toEqual('sub'); + expect(info.permissions).toEqual(31); + expect(info.size).toEqual(100); + expect(info.mtime.getTime()).toEqual(1436536800000); + expect(info.mimetype).toEqual('httpd/unix-directory'); + expect(info.etag).toEqual('66cfcabd79abb'); + }); + return promise.promise(); + }); + it('returns parent node in result if specified', function() { + var promise = client.getFolderContents('path/to space/文件夹', {includeParent: true}); + + expect(fakeServer.requests.length).toEqual(1); + + fakeServer.requests[0].respond( + 207, + {'Content-Type': 'application/xml'}, + folderContentsXml + ); + + promise.then(function(status, response) { + expect(status).toEqual(207); + expect(_.isArray(response)).toEqual(true); + + expect(response.length).toEqual(3); + + // root entry + var info = response[0]; + expect(info instanceof OC.Files.FileInfo).toEqual(true); + expect(info.id).toEqual(11); + expect(info.path).toEqual('/path/to space'); + expect(info.name).toEqual('文件夹'); + expect(info.permissions).toEqual(31); + expect(info.size).toEqual(120); + expect(info.mtime.getTime()).toEqual(1436522405000); + expect(info.mimetype).toEqual('httpd/unix-directory'); + expect(info.etag).toEqual('56cfcabd79abb'); + + // the two other entries follow + expect(response[1].id).toEqual(51); + expect(response[2].id).toEqual(15); + }); + + return promise; + }); + it('rejects promise when an error occurred', function() { + var promise = client.getFolderContents('path/to space/文件夹', {includeParent: true}); + return respondAndCheckError(promise, 404); + }); + it('throws exception if arguments are missing', function() { + // TODO + }); + }); + + describe('file info', function() { + var responseXml = + '' + + '' + + makeResponseBlock( + '/owncloud/remote.php/webdav/path/to%20space/%E6%96%87%E4%BB%B6%E5%A4%B9/', + { + 'd:getlastmodified': 'Fri, 10 Jul 2015 10:00:05 GMT', + 'd:getetag': '"56cfcabd79abb"', + 'd:resourcetype': '', + 'oc:id': '00000011oc2d13a6a068', + 'oc:permissions': 'RDNVCK', + 'oc:size': 120 + }, + [ + 'd:getcontenttype', + 'd:getcontentlength' + ] + ) + + ''; + + it('sends PROPFIND with zero depth to get single file info', function() { + client.getFileInfo('path/to space/文件夹'); + + expect(fakeServer.requests.length).toEqual(1); + expect(fakeServer.requests[0].method).toEqual('PROPFIND'); + expect(fakeServer.requests[0].url).toEqual(baseUrl + 'path/to%20space/%E6%96%87%E4%BB%B6%E5%A4%B9'); + expect(fakeServer.requests[0].requestHeaders.Depth).toEqual(0); + + var props = getRequestedProperties(fakeServer.requests[0].requestBody); + expect(props).toContain('{DAV:}getlastmodified'); + expect(props).toContain('{DAV:}getcontentlength'); + expect(props).toContain('{DAV:}getcontenttype'); + expect(props).toContain('{DAV:}getetag'); + expect(props).toContain('{DAV:}resourcetype'); + expect(props).toContain('{http://owncloud.org/ns}id'); + expect(props).toContain('{http://owncloud.org/ns}size'); + expect(props).toContain('{http://owncloud.org/ns}permissions'); + }); + it('parses the result into a FileInfo', function() { + var promise = client.getFileInfo('path/to space/文件夹'); + + expect(fakeServer.requests.length).toEqual(1); + + fakeServer.requests[0].respond( + 207, + {'Content-Type': 'application/xml'}, + responseXml + ); + + promise.then(function(status, response) { + expect(status).toEqual(207); + expect(_.isArray(response)).toEqual(false); + + var info = response; + expect(info instanceof OC.Files.FileInfo).toEqual(true); + expect(info.id).toEqual(11); + expect(info.path).toEqual('/path/to space'); + expect(info.name).toEqual('文件夹'); + expect(info.permissions).toEqual(31); + expect(info.size).toEqual(120); + expect(info.mtime.getTime()).toEqual(1436522405000); + expect(info.mimetype).toEqual('httpd/unix-directory'); + expect(info.etag).toEqual('56cfcabd79abb'); + }); + + return promise; + }); + it('properly parses entry inside root', function() { + var responseXml = + '' + + '' + + makeResponseBlock( + '/owncloud/remote.php/webdav/in%20root', + { + 'd:getlastmodified': 'Fri, 10 Jul 2015 10:00:05 GMT', + 'd:getetag': '"56cfcabd79abb"', + 'd:resourcetype': '', + 'oc:id': '00000011oc2d13a6a068', + 'oc:permissions': 'RDNVCK', + 'oc:size': 120 + }, + [ + 'd:getcontenttype', + 'd:getcontentlength' + ] + ) + + ''; + + var promise = client.getFileInfo('in root'); + + expect(fakeServer.requests.length).toEqual(1); + + fakeServer.requests[0].respond( + 207, + {'Content-Type': 'application/xml'}, + responseXml + ); + + promise.then(function(status, response) { + expect(status).toEqual(207); + expect(_.isArray(response)).toEqual(false); + + var info = response; + expect(info instanceof OC.Files.FileInfo).toEqual(true); + expect(info.id).toEqual(11); + expect(info.path).toEqual('/'); + expect(info.name).toEqual('in root'); + expect(info.permissions).toEqual(31); + expect(info.size).toEqual(120); + expect(info.mtime.getTime()).toEqual(1436522405000); + expect(info.mimetype).toEqual('httpd/unix-directory'); + expect(info.etag).toEqual('56cfcabd79abb'); + }); + + return promise; + }); + it('rejects promise when an error occurred', function() { + var promise = client.getFileInfo('path/to space/文件夹'); + return respondAndCheckError(promise, 404); + }); + it('throws exception if arguments are missing', function() { + // TODO + }); + }); + + describe('permissions', function() { + + function getFileInfoWithPermission(webdavPerm, isFile) { + var props = { + 'd:getlastmodified': 'Fri, 10 Jul 2015 13:38:05 GMT', + 'd:getetag': '"559fcabd79a38"', + 'd:getcontentlength': 250, + 'oc:id': '00000051oc2d13a6a068', + 'oc:permissions': webdavPerm, + }; + + if (isFile) { + props['d:getcontenttype'] = 'text/plain'; + } else { + props['d:resourcetype'] = ''; + } + + var responseXml = + '' + + '' + + makeResponseBlock( + '/owncloud/remote.php/webdav/file.txt', + props + ) + + ''; + var promise = client.getFileInfo('file.txt'); + + expect(fakeServer.requests.length).toEqual(1); + fakeServer.requests[0].respond( + 207, + {'Content-Type': 'application/xml'}, + responseXml + ); + + fakeServer.restore(); + fakeServer = sinon.fakeServer.create(); + + return promise; + } + + function testPermission(permission, isFile, expectedPermissions) { + var promise = getFileInfoWithPermission(permission, isFile); + promise.then(function(result) { + expect(result.permissions).toEqual(expectedPermissions); + }); + return promise; + } + + function testMountType(permission, isFile, expectedMountType) { + var promise = getFileInfoWithPermission(permission, isFile); + promise.then(function(result) { + expect(result.mountType).toEqual(expectedMountType); + }); + return promise; + } + + it('properly parses file permissions', function() { + // permission, isFile, expectedPermissions + var testCases = [ + ['', true, OC.PERMISSION_READ], + ['C', true, OC.PERMISSION_READ | OC.PERMISSION_CREATE], + ['K', true, OC.PERMISSION_READ | OC.PERMISSION_CREATE], + ['W', true, OC.PERMISSION_READ | OC.PERMISSION_CREATE | OC.PERMISSION_UPDATE], + ['D', true, OC.PERMISSION_READ | OC.PERMISSION_DELETE], + ['R', true, OC.PERMISSION_READ | OC.PERMISSION_SHARE], + ['CKWDR', true, OC.PERMISSION_ALL] + ]; + return Promise.all( + _.map(testCases, function(testCase) { + return testPermission.apply(testCase); + }) + ); + }); + it('properly parses folder permissions', function() { + var testCases = [ + ['', false, OC.PERMISSION_READ], + ['C', false, OC.PERMISSION_READ | OC.PERMISSION_CREATE | OC.PERMISSION_UPDATE], + ['K', false, OC.PERMISSION_READ | OC.PERMISSION_CREATE | OC.PERMISSION_UPDATE], + ['W', false, OC.PERMISSION_READ | OC.PERMISSION_UPDATE], + ['D', false, OC.PERMISSION_READ | OC.PERMISSION_DELETE], + ['R', false, OC.PERMISSION_READ | OC.PERMISSION_SHARE], + ['CKWDR', false, OC.PERMISSION_ALL] + ]; + + return Promise.all( + _.map(testCases, function(testCase) { + return testPermission.apply(testCase); + }) + ); + }); + it('properly parses mount types', function() { + var testCases = [ + ['CKWDR', false, null], + ['M', false, 'external'], + ['S', false, 'shared'], + ['SM', false, 'shared'] + ]; + + return Promise.all( + _.map(testCases, function(testCase) { + return testMountType.apply(testCase); + }) + ); + }); + }); + + describe('get file contents', function() { + it('returns file contents', function() { + var promise = client.getFileContents('path/to space/文件夹/One.txt'); + + expect(fakeServer.requests.length).toEqual(1); + expect(fakeServer.requests[0].method).toEqual('GET'); + expect(fakeServer.requests[0].url).toEqual(baseUrl + 'path/to%20space/%E6%96%87%E4%BB%B6%E5%A4%B9/One.txt'); + + fakeServer.requests[0].respond( + 200, + {'Content-Type': 'text/plain'}, + 'some contents' + ); + + promise.then(function(status, response) { + expect(status).toEqual(200); + expect(response).toEqual('some contents'); + }); + + return promise; + }); + it('rejects promise when an error occurred', function() { + var promise = client.getFileContents('path/to space/文件夹/One.txt'); + return respondAndCheckError(promise, 409); + }); + it('throws exception if arguments are missing', function() { + // TODO + }); + }); + + describe('put file contents', function() { + it('sends PUT with file contents', function() { + var promise = client.putFileContents( + 'path/to space/文件夹/One.txt', + 'some contents' + ); + + expect(fakeServer.requests.length).toEqual(1); + expect(fakeServer.requests[0].method).toEqual('PUT'); + expect(fakeServer.requests[0].url).toEqual(baseUrl + 'path/to%20space/%E6%96%87%E4%BB%B6%E5%A4%B9/One.txt'); + expect(fakeServer.requests[0].requestBody).toEqual('some contents'); + expect(fakeServer.requests[0].requestHeaders['If-None-Match']).toEqual('*'); + expect(fakeServer.requests[0].requestHeaders['Content-Type']).toEqual('text/plain;charset=utf-8'); + + return respondAndCheckStatus(promise, 201); + }); + it('sends PUT with file contents with headers matching options', function() { + var promise = client.putFileContents( + 'path/to space/文件夹/One.txt', + 'some contents', + { + overwrite: false, + contentType: 'text/markdown' + } + ); + + expect(fakeServer.requests.length).toEqual(1); + expect(fakeServer.requests[0].method).toEqual('PUT'); + expect(fakeServer.requests[0].url).toEqual(baseUrl + 'path/to%20space/%E6%96%87%E4%BB%B6%E5%A4%B9/One.txt'); + expect(fakeServer.requests[0].requestBody).toEqual('some contents'); + expect(fakeServer.requests[0].requestHeaders['If-None-Match']).not.toBeDefined(); + expect(fakeServer.requests[0].requestHeaders['Content-Type']).toEqual('text/markdown;charset=utf-8'); + + return respondAndCheckStatus(promise, 201); + }); + it('rejects promise when an error occurred', function() { + var promise = client.putFileContents( + 'path/to space/文件夹/One.txt', + 'some contents' + ); + return respondAndCheckError(promise, 409); + }); + it('throws exception if arguments are missing', function() { + // TODO + }); + }); + + describe('create directory', function() { + it('sends MKCOL with specified path', function() { + var promise = client.createDirectory('path/to space/文件夹/new dir'); + + expect(fakeServer.requests.length).toEqual(1); + expect(fakeServer.requests[0].method).toEqual('MKCOL'); + expect(fakeServer.requests[0].url).toEqual(baseUrl + 'path/to%20space/%E6%96%87%E4%BB%B6%E5%A4%B9/new%20dir'); + + return respondAndCheckStatus(promise, 201); + }); + it('rejects promise when an error occurred', function() { + var promise = client.createDirectory('path/to space/文件夹/new dir'); + return respondAndCheckError(promise, 404); + }); + it('throws exception if arguments are missing', function() { + // TODO + }); + }); + + describe('deletion', function() { + it('sends DELETE with specified path', function() { + var promise = client.remove('path/to space/文件夹'); + + expect(fakeServer.requests.length).toEqual(1); + expect(fakeServer.requests[0].method).toEqual('DELETE'); + expect(fakeServer.requests[0].url).toEqual(baseUrl + 'path/to%20space/%E6%96%87%E4%BB%B6%E5%A4%B9'); + + return respondAndCheckStatus(promise, 201); + }); + it('rejects promise when an error occurred', function() { + var promise = client.remove('path/to space/文件夹'); + return respondAndCheckError(promise, 404); + }); + it('throws exception if arguments are missing', function() { + // TODO + }); + }); + + describe('move', function() { + it('sends MOVE with specified paths with fail on overwrite by default', function() { + var promise = client.move( + 'path/to space/文件夹', + 'path/to space/anotherdir/文件夹' + ); + + expect(fakeServer.requests.length).toEqual(1); + expect(fakeServer.requests[0].method).toEqual('MOVE'); + expect(fakeServer.requests[0].url).toEqual(baseUrl + 'path/to%20space/%E6%96%87%E4%BB%B6%E5%A4%B9'); + expect(fakeServer.requests[0].requestHeaders.Destination) + .toEqual(baseUrl + 'path/to%20space/anotherdir/%E6%96%87%E4%BB%B6%E5%A4%B9'); + expect(fakeServer.requests[0].requestHeaders.Overwrite) + .toEqual('F'); + + return respondAndCheckStatus(promise, 201); + }); + it('sends MOVE with silent overwrite mode when specified', function() { + var promise = client.move( + 'path/to space/文件夹', + 'path/to space/anotherdir/文件夹', + {allowOverwrite: true} + ); + + expect(fakeServer.requests.length).toEqual(1); + expect(fakeServer.requests[0].method).toEqual('MOVE'); + expect(fakeServer.requests[0].url).toEqual(baseUrl + 'path/to%20space/%E6%96%87%E4%BB%B6%E5%A4%B9'); + expect(fakeServer.requests[0].requestHeaders.Destination) + .toEqual(baseUrl + 'path/to%20space/anotherdir/%E6%96%87%E4%BB%B6%E5%A4%B9'); + expect(fakeServer.requests[0].requestHeaders.Overwrite) + .not.toBeDefined(); + + return respondAndCheckStatus(promise, 201); + }); + it('rejects promise when an error occurred', function() { + var promise = client.move( + 'path/to space/文件夹', + 'path/to space/anotherdir/文件夹', + {allowOverwrite: true} + ); + return respondAndCheckError(promise, 404); + }); + it('throws exception if arguments are missing', function() { + // TODO + }); + }); +}); diff --git a/tests/karma.config.js b/tests/karma.config.js index 64a94ef230..dc621ae0f7 100644 --- a/tests/karma.config.js +++ b/tests/karma.config.js @@ -164,15 +164,15 @@ module.exports = function(config) { // need to test the core app as well ? if (testCore) { // core tests - files.push(corePath + 'tests/specs/*.js'); + files.push(corePath + 'tests/specs/**/*.js'); } function addApp(app) { // if only a string was specified, expand to structure if (typeof(app) === 'string') { app = { - srcFiles: 'apps/' + app + '/js/*.js', - testFiles: 'apps/' + app + '/tests/js/*.js' + srcFiles: 'apps/' + app + '/js/**/*.js', + testFiles: 'apps/' + app + '/tests/js/**/*.js' }; }