Merge branch 'master' of https://lab.nexedi.com/YaxelPerez/jio

Makefile

@@ -26,7 +26,7 @@ TESTDIR = test
 EXAMPLEDIR = examples
 EXTERNALDIR = external
 
-VERSION = 3.35.0
+VERSION = 3.36.0
 JIOVERSION = ${DISTDIR}/jio-v${VERSION}.js
 JIOLATEST = ${DISTDIR}/jio-latest.js
 JIONODEVERSION = ${DISTDIR}/jio-v${VERSION}-node.js
@@ -141,6 +141,7 @@ ${JIOVERSION}: ${EXTERNALDIR}/URI.js \
 	${SRCDIR}/jio.storage/davstorage.js \
 	${SRCDIR}/jio.storage/gdrivestorage.js \
 	${SRCDIR}/jio.storage/unionstorage.js \
+	${SRCDIR}/jio.storage/linsharestorage.js \
 	${SRCDIR}/jio.storage/erp5storage.js \
 	${SRCDIR}/jio.storage/querystorage.js \
 	${SRCDIR}/jio.storage/drivetojiomapping.js \

dist/jio-latest.js

@@ -12959,6 +12959,316 @@ return new Parser;
   jIO.addStorage('union', UnionStorage);
 
 }(jIO, RSVP));
+/*
+ * Copyright 2019, Nexedi SA
+ *
+ * This program is free software: you can Use, Study, Modify and Redistribute
+ * it under the terms of the GNU General Public License version 3, or (at your
+ * option) any later version, as published by the Free Software Foundation.
+ *
+ * You can also Link and Combine this program with other software covered by
+ * the terms of any of the Free Software licenses or any of the Open Source
+ * Initiative approved licenses and Convey the resulting work. Corresponding
+ * source of such a combination shall include the source code for all other
+ * software used.
+ *
+ * This program is distributed WITHOUT ANY WARRANTY; without even the implied
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * See COPYING file for full licensing terms.
+ * See https://www.nexedi.com/licensing for rationale and options.
+ */
+/**
+ * JIO Linshare Storage. Type = "linshare".
+ * Linshare "database" storage.
+ * http://download.linshare.org/components/linshare-core/2.2.2/
+ * Can't set up id, implied can't put new document
+ */
+/*global jIO, RSVP, UriTemplate, FormData, Blob*/
+/*jslint nomen: true*/
+
+(function (jIO, RSVP, UriTemplate, FormData, Blob) {
+  "use strict";
+
+  function makeRequest(storage, uuid, options, download) {
+    if (options === undefined) {
+      options = {};
+    }
+    if (options.xhrFields === undefined) {
+      options.xhrFields = {};
+    }
+
+    if (options.headers === undefined) {
+      options.headers = {};
+    }
+
+    // Prefer JSON by default
+    if (download === true) {
+      options.url = storage._blob_template.expand({uuid: uuid});
+      options.dataType = 'blob';
+    } else {
+      options.url = storage._url_template.expand({uuid: uuid || ""});
+      if (!options.headers.hasOwnProperty('Accept')) {
+        options.headers.Accept = 'application/json';
+        options.dataType = 'json';
+      }
+    }
+
+    // Use cookie based auth
+    if (storage.hasOwnProperty('_access_token')) {
+      options.headers.Authorization = "Basic " + storage._access_token;
+    } else {
+      options.xhrFields.withCredentials = true;
+    }
+
+    return new RSVP.Queue()
+      .push(function () {
+        return jIO.util.ajax(options);
+      })
+      .push(function (event) {
+        if (download === true) {
+          return (
+            event.target.response ||
+            // sinon does not fill the response attribute
+            new Blob([event.target.responseText], {type: 'text/plain'})
+          );
+        }
+
+        return (
+          event.target.response ||
+          // sinon does not fill the response attribute
+          JSON.parse(event.target.responseText)
+        );
+      });
+  }
+
+  /**
+   * The JIO Linshare Storage extension
+   *
+   * @class LinshareStorage
+   * @constructor
+   */
+  function LinshareStorage(spec) {
+
+    if (typeof spec.url !== "string" || !spec.url) {
+      throw new TypeError("Linshare 'url' must be a string " +
+                          "which contains more than one character.");
+    }
+    this._url_template = UriTemplate.parse(
+      spec.url + '/linshare/webservice/rest/user/v2/documents/{uuid}'
+    );
+    this._blob_template = UriTemplate.parse(
+      spec.url + '/linshare/webservice/rest/user/v2/documents/{uuid}/download'
+    );
+
+    if (spec.hasOwnProperty('access_token')) {
+      this._access_token = spec.access_token;
+    }
+  }
+
+  var capacity_list = ['list', 'include'];
+  LinshareStorage.prototype.hasCapacity = function (name) {
+    return (capacity_list.indexOf(name) !== -1);
+  };
+
+  function sortByModificationDate(entry1, entry2) {
+    var date1 = entry1.modificationDate,
+      date2 = entry2.modificationDate;
+    return (date1 === date2) ? 0 : ((date1 < date2) ? 1 : -1);
+  }
+
+  function getDocumentList(storage, options) {
+    return makeRequest(storage, "", {
+      type: "GET"
+    })
+      .push(function (entry_list) {
+        // Linshare only allow to get the full list of documents
+        // First, sort the entries by modificationDate in order to
+        // drop the 'old' entries with the same 'name'
+        // (as linshare does not to update an existing doc)
+        entry_list.sort(sortByModificationDate);
+
+        // Only return one document per name
+        // Keep the newer document
+        var entry_dict = {},
+          i,
+          len = entry_list.length,
+          entry_name,
+          entry,
+          result_list = [];
+
+        for (i = 0; i < len; i += 1) {
+          entry_name = entry_list[i].name;
+
+          // If we only need one precise name, no need to check the others
+          if (!options.hasOwnProperty('only_id') ||
+              (options.only_id === entry_name)) {
+
+            if (!entry_dict.hasOwnProperty(entry_name)) {
+              entry = {
+                id: entry_name,
+                value: {},
+                _linshare_uuid: entry_list[i].uuid
+              };
+              if (options.include_docs === true) {
+                entry.doc = JSON.parse(entry_list[i].metaData) || {};
+              }
+              result_list.push(entry);
+
+              if (options.all_revision !== true) {
+                // If we only want to fetch 'one revision',
+                // ie, the latest document matching this id
+                entry_dict[entry_name] = null;
+
+                if (options.only_id === entry_name) {
+                  // Document has been found, no need to check all the others
+                  break;
+                }
+              }
+            }
+          }
+        }
+
+        return result_list;
+      });
+  }
+
+  LinshareStorage.prototype.buildQuery = function (options) {
+    return getDocumentList(this, {
+      include_docs: options.include_docs
+    });
+  };
+
+  LinshareStorage.prototype.get = function (id) {
+    // It is not possible to get a document by its name
+    // The only way is to list all of them, and find it manually
+    return getDocumentList(this, {
+      include_docs: true,
+      only_id: id
+    })
+      .push(function (result_list) {
+        if (result_list.length === 1) {
+          return result_list[0].doc;
+        }
+
+        throw new jIO.util.jIOError(
+          "Can't find document with id : " + id,
+          404
+        );
+      });
+  };
+
+  function createLinshareDocument(storage, id, doc, blob) {
+    var data = new FormData();
+    data.append('file', blob, id);
+    data.append('filesize', blob.size);
+    data.append('filename', id);
+    data.append('description', doc.title || doc.description || '');
+    data.append('metadata', jIO.util.stringify(doc));
+    return makeRequest(storage, '', {
+      type: 'POST',
+      data: data
+    });
+  }
+
+  LinshareStorage.prototype.put = function (id, doc) {
+    var storage = this;
+    return getDocumentList(storage, {
+      include_docs: true,
+      only_id: id
+    })
+      .push(function (result_list) {
+        if (result_list.length === 1) {
+          // Update existing document metadata
+          var data = {
+            uuid: result_list[0]._linshare_uuid,
+            metaData: jIO.util.stringify(doc),
+            name: id,
+            description: doc.title || doc.description || ''
+          };
+          return makeRequest(storage, result_list[0]._linshare_uuid, {
+            type: 'PUT',
+            headers: {'Content-Type': 'application/json'},
+            data: jIO.util.stringify(data)
+          });
+        }
+        // Create a new one
+        return createLinshareDocument(storage, id, doc, new Blob());
+      });
+  };
+
+  LinshareStorage.prototype.remove = function (id) {
+    var storage = this;
+    // Delete all entries matching the id
+    return getDocumentList(storage, {
+      only_id: id,
+      all_revision: true
+    })
+      .push(function (result_list) {
+        var promise_list = [],
+          i,
+          len = result_list.length;
+        for (i = 0; i < len; i += 1) {
+          promise_list.push(
+            makeRequest(storage, result_list[i]._linshare_uuid, {
+              type: "DELETE"
+            })
+          );
+        }
+        return RSVP.all(promise_list);
+      });
+  };
+
+  LinshareStorage.prototype.allAttachments = function (id) {
+    return this.get(id)
+      .push(function () {
+        return {enclosure: {}};
+      });
+  };
+
+  function restrictAttachmentId(name) {
+    if (name !== "enclosure") {
+      throw new jIO.util.jIOError(
+        "attachment name " + name + " is forbidden in linshare",
+        400
+      );
+    }
+  }
+
+  LinshareStorage.prototype.putAttachment = function (id, name, blob) {
+    restrictAttachmentId(name);
+    var storage = this;
+    return storage.get(id)
+      .push(function (doc) {
+        // Create a new document with the same id but a different blob content
+        return createLinshareDocument(storage, id, doc, blob);
+      });
+  };
+
+  LinshareStorage.prototype.getAttachment = function (id, name) {
+    restrictAttachmentId(name);
+    var storage = this;
+    // It is not possible to get a document by its name
+    // The only way is to list all of them, and find it manually
+    return getDocumentList(storage, {
+      only_id: id
+    })
+      .push(function (result_list) {
+        if (result_list.length === 1) {
+          return makeRequest(storage, result_list[0]._linshare_uuid, {
+          }, true);
+        }
+
+        throw new jIO.util.jIOError(
+          "Can't find document with id : " + id,
+          404
+        );
+      });
+  };
+
+  jIO.addStorage('linshare', LinshareStorage);
+
+}(jIO, RSVP, UriTemplate, FormData, Blob));
 /*
  * Copyright 2013, Nexedi SA
  *

examples/scenario.js

@@ -70,6 +70,23 @@
         }
       });
 
+      ///////////////////////////
+      // Linshare storage
+      ///////////////////////////
+//       return g.run({
+//         type: "query",
+//         sub_storage: {
+//           type: "uuid",
+//           sub_storage: {
+//             type: "linshare",
+//             url: "https://demo.linshare.org/",
+//             credential_token: window.btoa(
+//               'user1@linshare.org' + ':' + 'password1'
+//             )
+//           }
+//         }
+//       });
+
       ///////////////////////////
       // WebSQL storage
       ///////////////////////////

package.json

 {
   "name": "jio",
-  "version": "v3.35.0",
+  "version": "v3.36.0",
   "license": "GPLv3+",
   "author": "Nexedi SA",
   "contributors": [

src/jio.storage/linsharestorage.js

+/*
+ * Copyright 2019, Nexedi SA
+ *
+ * This program is free software: you can Use, Study, Modify and Redistribute
+ * it under the terms of the GNU General Public License version 3, or (at your
+ * option) any later version, as published by the Free Software Foundation.
+ *
+ * You can also Link and Combine this program with other software covered by
+ * the terms of any of the Free Software licenses or any of the Open Source
+ * Initiative approved licenses and Convey the resulting work. Corresponding
+ * source of such a combination shall include the source code for all other
+ * software used.
+ *
+ * This program is distributed WITHOUT ANY WARRANTY; without even the implied
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * See COPYING file for full licensing terms.
+ * See https://www.nexedi.com/licensing for rationale and options.
+ */
+/**
+ * JIO Linshare Storage. Type = "linshare".
+ * Linshare "database" storage.
+ * http://download.linshare.org/components/linshare-core/2.2.2/
+ * Can't set up id, implied can't put new document
+ */
+/*global jIO, RSVP, UriTemplate, FormData, Blob*/
+/*jslint nomen: true*/
+
+(function (jIO, RSVP, UriTemplate, FormData, Blob) {
+  "use strict";
+
+  function makeRequest(storage, uuid, options, download) {
+    if (options === undefined) {
+      options = {};
+    }
+    if (options.xhrFields === undefined) {
+      options.xhrFields = {};
+    }
+
+    if (options.headers === undefined) {
+      options.headers = {};
+    }
+
+    // Prefer JSON by default
+    if (download === true) {
+      options.url = storage._blob_template.expand({uuid: uuid});
+      options.dataType = 'blob';
+    } else {
+      options.url = storage._url_template.expand({uuid: uuid || ""});
+      if (!options.headers.hasOwnProperty('Accept')) {
+        options.headers.Accept = 'application/json';
+        options.dataType = 'json';
+      }
+    }
+
+    // Use cookie based auth
+    if (storage.hasOwnProperty('_access_token')) {
+      options.headers.Authorization = "Basic " + storage._access_token;
+    } else {
+      options.xhrFields.withCredentials = true;
+    }
+
+    return new RSVP.Queue()
+      .push(function () {
+        return jIO.util.ajax(options);
+      })
+      .push(function (event) {
+        if (download === true) {
+          return (
+            event.target.response ||
+            // sinon does not fill the response attribute
+            new Blob([event.target.responseText], {type: 'text/plain'})
+          );
+        }
+
+        return (
+          event.target.response ||
+          // sinon does not fill the response attribute
+          JSON.parse(event.target.responseText)
+        );
+      });
+  }
+
+  /**
+   * The JIO Linshare Storage extension
+   *
+   * @class LinshareStorage
+   * @constructor
+   */
+  function LinshareStorage(spec) {
+
+    if (typeof spec.url !== "string" || !spec.url) {
+      throw new TypeError("Linshare 'url' must be a string " +
+                          "which contains more than one character.");
+    }
+    this._url_template = UriTemplate.parse(
+      spec.url + '/linshare/webservice/rest/user/v2/documents/{uuid}'
+    );
+    this._blob_template = UriTemplate.parse(
+      spec.url + '/linshare/webservice/rest/user/v2/documents/{uuid}/download'
+    );
+
+    if (spec.hasOwnProperty('access_token')) {
+      this._access_token = spec.access_token;
+    }
+  }
+
+  var capacity_list = ['list', 'include'];
+  LinshareStorage.prototype.hasCapacity = function (name) {
+    return (capacity_list.indexOf(name) !== -1);
+  };
+
+  function sortByModificationDate(entry1, entry2) {
+    var date1 = entry1.modificationDate,
+      date2 = entry2.modificationDate;
+    return (date1 === date2) ? 0 : ((date1 < date2) ? 1 : -1);
+  }
+
+  function getDocumentList(storage, options) {
+    return makeRequest(storage, "", {
+      type: "GET"
+    })
+      .push(function (entry_list) {
+        // Linshare only allow to get the full list of documents
+        // First, sort the entries by modificationDate in order to
+        // drop the 'old' entries with the same 'name'
+        // (as linshare does not to update an existing doc)
+        entry_list.sort(sortByModificationDate);
+
+        // Only return one document per name
+        // Keep the newer document
+        var entry_dict = {},
+          i,
+          len = entry_list.length,
+          entry_name,
+          entry,
+          result_list = [];
+
+        for (i = 0; i < len; i += 1) {
+          entry_name = entry_list[i].name;
+
+          // If we only need one precise name, no need to check the others
+          if (!options.hasOwnProperty('only_id') ||
+              (options.only_id === entry_name)) {
+
+            if (!entry_dict.hasOwnProperty(entry_name)) {
+              entry = {
+                id: entry_name,
+                value: {},
+                _linshare_uuid: entry_list[i].uuid
+              };
+              if (options.include_docs === true) {
+                entry.doc = JSON.parse(entry_list[i].metaData) || {};
+              }
+              result_list.push(entry);
+
+              if (options.all_revision !== true) {
+                // If we only want to fetch 'one revision',
+                // ie, the latest document matching this id
+                entry_dict[entry_name] = null;
+
+                if (options.only_id === entry_name) {
+                  // Document has been found, no need to check all the others
+                  break;
+                }
+              }
+            }
+          }
+        }
+
+        return result_list;
+      });
+  }
+
+  LinshareStorage.prototype.buildQuery = function (options) {
+    return getDocumentList(this, {
+      include_docs: options.include_docs
+    });
+  };
+
+  LinshareStorage.prototype.get = function (id) {
+    // It is not possible to get a document by its name
+    // The only way is to list all of them, and find it manually
+    return getDocumentList(this, {
+      include_docs: true,
+      only_id: id
+    })
+      .push(function (result_list) {
+        if (result_list.length === 1) {
+          return result_list[0].doc;
+        }
+
+        throw new jIO.util.jIOError(
+          "Can't find document with id : " + id,
+          404
+        );
+      });
+  };
+
+  function createLinshareDocument(storage, id, doc, blob) {
+    var data = new FormData();
+    data.append('file', blob, id);
+    data.append('filesize', blob.size);
+    data.append('filename', id);
+    data.append('description', doc.title || doc.description || '');
+    data.append('metadata', jIO.util.stringify(doc));
+    return makeRequest(storage, '', {
+      type: 'POST',
+      data: data
+    });
+  }
+
+  LinshareStorage.prototype.put = function (id, doc) {
+    var storage = this;
+    return getDocumentList(storage, {
+      include_docs: true,
+      only_id: id
+    })
+      .push(function (result_list) {
+        if (result_list.length === 1) {
+          // Update existing document metadata
+          var data = {
+            uuid: result_list[0]._linshare_uuid,
+            metaData: jIO.util.stringify(doc),
+            name: id,
+            description: doc.title || doc.description || ''
+          };
+          return makeRequest(storage, result_list[0]._linshare_uuid, {
+            type: 'PUT',
+            headers: {'Content-Type': 'application/json'},
+            data: jIO.util.stringify(data)
+          });
+        }
+        // Create a new one
+        return createLinshareDocument(storage, id, doc, new Blob());
+      });
+  };
+
+  LinshareStorage.prototype.remove = function (id) {
+    var storage = this;
+    // Delete all entries matching the id
+    return getDocumentList(storage, {
+      only_id: id,
+      all_revision: true
+    })
+      .push(function (result_list) {
+        var promise_list = [],
+          i,
+          len = result_list.length;
+        for (i = 0; i < len; i += 1) {
+          promise_list.push(
+            makeRequest(storage, result_list[i]._linshare_uuid, {
+              type: "DELETE"
+            })
+          );
+        }
+        return RSVP.all(promise_list);
+      });
+  };
+
+  LinshareStorage.prototype.allAttachments = function (id) {
+    return this.get(id)
+      .push(function () {
+        return {enclosure: {}};
+      });
+  };
+
+  function restrictAttachmentId(name) {
+    if (name !== "enclosure") {
+      throw new jIO.util.jIOError(
+        "attachment name " + name + " is forbidden in linshare",
+        400
+      );
+    }
+  }
+
+  LinshareStorage.prototype.putAttachment = function (id, name, blob) {
+    restrictAttachmentId(name);
+    var storage = this;
+    return storage.get(id)
+      .push(function (doc) {
+        // Create a new document with the same id but a different blob content
+        return createLinshareDocument(storage, id, doc, blob);
+      });
+  };
+
+  LinshareStorage.prototype.getAttachment = function (id, name) {
+    restrictAttachmentId(name);
+    var storage = this;
+    // It is not possible to get a document by its name
+    // The only way is to list all of them, and find it manually
+    return getDocumentList(storage, {
+      only_id: id
+    })
+      .push(function (result_list) {
+        if (result_list.length === 1) {
+          return makeRequest(storage, result_list[0]._linshare_uuid, {
+          }, true);
+        }
+
+        throw new jIO.util.jIOError(
+          "Can't find document with id : " + id,
+          404
+        );
+      });
+  };
+
+  jIO.addStorage('linshare', LinshareStorage);
+
+}(jIO, RSVP, UriTemplate, FormData, Blob));

test/jio.storage/linsharestorage.tests.js

+/*
+ * Copyright 2019, Nexedi SA
+ *
+ * This program is free software: you can Use, Study, Modify and Redistribute
+ * it under the terms of the GNU General Public License version 3, or (at your
+ * option) any later version, as published by the Free Software Foundation.
+ *
+ * You can also Link and Combine this program with other software covered by
+ * the terms of any of the Free Software licenses or any of the Open Source
+ * Initiative approved licenses and Convey the resulting work. Corresponding
+ * source of such a combination shall include the source code for all other
+ * software used.
+ *
+ * This program is distributed WITHOUT ANY WARRANTY; without even the implied
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * See COPYING file for full licensing terms.
+ * See https://www.nexedi.com/licensing for rationale and options.
+ */
+/*jslint nomen: true */
+/*global Blob, sinon, FormData*/
+(function (jIO, QUnit, Blob, sinon, FormData) {
+  "use strict";
+  var test = QUnit.test,
+    stop = QUnit.stop,
+    start = QUnit.start,
+    ok = QUnit.ok,
+    expect = QUnit.expect,
+    equal = QUnit.equal,
+    deepEqual = QUnit.deepEqual,
+    module = QUnit.module,
+    domain = "https://example.org/foo";
+
+  /////////////////////////////////////////////////////////////////
+  // LinshareStorage constructor
+  /////////////////////////////////////////////////////////////////
+  module("LinshareStorage.constructor");
+
+  test("create storage", function () {
+    var jio = jIO.createJIO({
+      type: "linshare",
+      url: "https://example.org/foo"
+    });
+    equal(jio.__type, "linshare");
+    deepEqual(
+      jio.__storage._url_template.templateText,
+      "https://example.org/foo/linshare/webservice/rest/user/" +
+        "v2/documents/{uuid}"
+    );
+    deepEqual(
+      jio.__storage._blob_template.templateText,
+      "https://example.org/foo/linshare/webservice/rest/user/" +
+        "v2/documents/{uuid}/download"
+    );
+    equal(jio.__storage._credential_token, undefined);
+  });
+
+  test("create storage store access token", function () {
+    var jio = jIO.createJIO({
+      type: "linshare",
+      url: "https://example.org/bar",
+      access_token: "azerty"
+    });
+    equal(jio.__type, "linshare");
+    deepEqual(
+      jio.__storage._url_template.templateText,
+      "https://example.org/bar/linshare/webservice/rest/user/" +
+        "v2/documents/{uuid}"
+    );
+    deepEqual(
+      jio.__storage._blob_template.templateText,
+      "https://example.org/bar/linshare/webservice/rest/user/" +
+        "v2/documents/{uuid}/download"
+    );
+    equal(jio.__storage._access_token, "azerty");
+  });
+
+  /////////////////////////////////////////////////////////////////
+  // LinshareStorage hasCapacity
+  /////////////////////////////////////////////////////////////////
+  module("LinshareStorage.hasCapacity", {
+    setup: function () {
+      this.jio = jIO.createJIO({
+        type: "linshare",
+        url: "https://example.org/foo"
+      });
+    }
+  });
+
+  test("check capacities", function () {
+    ok(this.jio.hasCapacity("list"));
+    ok(this.jio.hasCapacity("include"));
+  });
+
+  /////////////////////////////////////////////////////////////////
+  // LinshareStorage.allDocs
+  /////////////////////////////////////////////////////////////////
+  module("LinshareStorage.allDocs", {
+    setup: function () {
+
+      this.server = sinon.fakeServer.create();
+      this.server.autoRespond = true;
+      this.server.autoRespondAfter = 5;
+
+      this.jio = jIO.createJIO({
+        type: "linshare",
+        url: domain
+      });
+    },
+    teardown: function () {
+      this.server.restore();
+      delete this.server;
+    }
+  });
+
+  test("get all documents", function () {
+    var search_url = domain + "/linshare/webservice/rest/user/v2/documents/",
+      search_result = JSON.stringify([
+        {
+          uuid: 'uuid1',
+          name: 'foo1',
+          modificationDate: '2',
+        }, {
+          uuid: 'uuid2',
+          name: 'foo2',
+          modificationDate: '1',
+        }
+      ]),
+      server = this.server;
+
+    this.server.respondWith("GET", search_url, [200, {
+      "Content-Type": "application/json"
+    }, search_result]);
+
+    stop();
+    expect(7);
+
+    this.jio.allDocs()
+      .then(function (result) {
+        deepEqual(result, {
+          data: {
+            rows: [{
+              _linshare_uuid: "uuid1",
+              id: "foo1",
+              value: {}
+            }, {
+              _linshare_uuid: "uuid2",
+              id: "foo2",
+              value: {}
+            }],
+            total_rows: 2
+          }
+        }, "Check document");
+        equal(server.requests.length, 1);
+        equal(server.requests[0].method, "GET");
+        equal(server.requests[0].url, search_url);
+        equal(server.requests[0].requestBody, undefined);
+        equal(server.requests[0].withCredentials, true);
+        deepEqual(server.requests[0].requestHeaders, {
+          "Accept": "application/json"
+        });
+      })
+      .fail(function (error) {
+        ok(false, error);
+      })
+      .always(function () {
+        start();
+      });
+  });
+
+  test("get all documents with access token", function () {
+    var search_url = domain + "/linshare/webservice/rest/user/v2/documents/",
+      search_result = JSON.stringify([
+        {
+          uuid: 'uuid1',
+          name: 'foo1',
+          modificationDate: '2',
+        }, {
+          uuid: 'uuid2',
+          name: 'foo2',
+          modificationDate: '1',
+        }
+      ]),
+      server = this.server,
+      token = 'barfoobar';
+
+    this.server.respondWith("GET", search_url, [200, {
+      "Content-Type": "application/json"
+    }, search_result]);
+
+    stop();
+    expect(7);
+
+    this.jio = jIO.createJIO({
+      type: "linshare",
+      url: domain,
+      access_token: token
+    });
+
+    this.jio.allDocs()
+      .then(function (result) {
+        deepEqual(result, {
+          data: {
+            rows: [{
+              _linshare_uuid: "uuid1",
+              id: "foo1",
+              value: {}
+            }, {
+              _linshare_uuid: "uuid2",
+              id: "foo2",
+              value: {}
+            }],
+            total_rows: 2
+          }
+        }, "Check document");
+        equal(server.requests.length, 1);
+        equal(server.requests[0].method, "GET");
+        equal(server.requests[0].url, search_url);
+        equal(server.requests[0].requestBody, undefined);
+        equal(server.requests[0].withCredentials, undefined);
+        deepEqual(server.requests[0].requestHeaders, {
+          "Accept": "application/json",
+          "Authorization": "Basic " + token
+        });
+      })
+      .fail(function (error) {
+        ok(false, error);
+      })
+      .always(function () {
+        start();
+      });
+  });
+
+  test("get all documents and include docs", function () {
+    var search_url = domain + "/linshare/webservice/rest/user/v2/documents/",
+      search_result = JSON.stringify([
+        {
+          uuid: 'uuid1',
+          name: 'foo1',
+          modificationDate: '2',
+          metaData: JSON.stringify({
+            title: 'foo1title'
+          })
+        }, {
+          uuid: 'uuid2',
+          name: 'foo2',
+          modificationDate: '1',
+          metaData: JSON.stringify({
+            reference: 'foo2reference'
+          })
+        }
+      ]),
+      server = this.server;
+
+    this.server.respondWith("GET", search_url, [200, {
+      "Content-Type": "application/json"
+    }, search_result]);
+
+    stop();
+    expect(7);
+
+    this.jio.allDocs({include_docs: true})
+      .then(function (result) {
+        deepEqual(result, {
+          data: {
+            rows: [{
+              _linshare_uuid: "uuid1",
+              id: "foo1",
+              value: {},
+              doc: {title: "foo1title"}
+            }, {
+              _linshare_uuid: "uuid2",
+              id: "foo2",
+              value: {},
+              doc: {reference: "foo2reference"}
+            }],
+            total_rows: 2
+          }
+        }, "Check document");
+        equal(server.requests.length, 1);
+        equal(server.requests[0].method, "GET");
+        equal(server.requests[0].url, search_url);
+        equal(server.requests[0].requestBody, undefined);
+        equal(server.requests[0].withCredentials, true);
+        deepEqual(server.requests[0].requestHeaders, {
+          "Accept": "application/json"
+        });
+      })
+      .fail(function (error) {
+        ok(false, error);
+      })
+      .always(function () {
+        start();
+      });
+  });
+
+  test("get all documents and keep only one doc per name", function () {
+    var search_url = domain + "/linshare/webservice/rest/user/v2/documents/",
+      search_result = JSON.stringify([
+        {
+          uuid: 'uuid1',
+          name: 'foo',
+          modificationDate: '3',
+        }, {
+          uuid: 'uuid2',
+          name: 'foo',
+          modificationDate: '2',
+        }, {
+          uuid: 'uuid3',
+          name: 'foo',
+          modificationDate: '1',
+        }
+      ]),
+      server = this.server;
+
+    this.server.respondWith("GET", search_url, [200, {
+      "Content-Type": "application/json"
+    }, search_result]);
+
+    stop();
+    expect(7);
+
+    this.jio.allDocs()
+      .then(function (result) {
+        deepEqual(result, {
+          data: {
+            rows: [{
+              _linshare_uuid: "uuid1",
+              id: "foo",
+              value: {}
+            }],
+            total_rows: 1
+          }
+        }, "Check document");
+        equal(server.requests.length, 1);
+        equal(server.requests[0].method, "GET");
+        equal(server.requests[0].url, search_url);
+        equal(server.requests[0].requestBody, undefined);
+        equal(server.requests[0].withCredentials, true);
+        deepEqual(server.requests[0].requestHeaders, {
+          "Accept": "application/json"
+        });
+      })
+      .fail(function (error) {
+        ok(false, error);
+      })
+      .always(function () {
+        start();
+      });
+  });
+
+  /////////////////////////////////////////////////////////////////
+  // LinshareStorage.get
+  /////////////////////////////////////////////////////////////////
+  module("LinshareStorage.get", {
+    setup: function () {
+
+      this.server = sinon.fakeServer.create();
+      this.server.autoRespond = true;
+      this.server.autoRespondAfter = 5;
+
+      this.jio = jIO.createJIO({
+        type: "linshare",
+        url: domain
+      });
+    },
+    teardown: function () {
+      this.server.restore();
+      delete this.server;
+    }
+  });
+
+  test("get inexistent document", function () {
+    var search_url = domain + "/linshare/webservice/rest/user/v2/documents/",
+      search_result = JSON.stringify([
+        {
+          uuid: 'uuid1',
+          name: 'foo1',
+          modificationDate: '2',
+        }, {
+          uuid: 'uuid2',
+          name: 'foo2',
+          modificationDate: '1'
+        }
+      ]),
+      server = this.server;
+
+    this.server.respondWith("GET", search_url, [200, {
+      "Content-Type": "application/json"
+    }, search_result]);
+
+    stop();
+    expect(9);
+
+    this.jio.get('foo')
+      .fail(function (error) {
+        ok(error instanceof jIO.util.jIOError);
+        equal(error.message, "Can't find document with id : foo");
+        equal(error.status_code, 404);
+
+        equal(server.requests.length, 1);
+        equal(server.requests[0].method, "GET");
+        equal(server.requests[0].url, search_url);
+        equal(server.requests[0].requestBody, undefined);
+        equal(server.requests[0].withCredentials, true);
+        deepEqual(server.requests[0].requestHeaders, {
+          "Accept": "application/json"
+        });
+      })
+      .fail(function (error) {
+        ok(false, error);
+      })
+      .always(function () {
+        start();
+      });
+  });
+
+  test("get a document", function () {
+    var search_url = domain + "/linshare/webservice/rest/user/v2/documents/",
+      search_result = JSON.stringify([
+        {
+          uuid: 'uuid1',
+          name: 'foo1',
+          modificationDate: '2',
+        }, {
+          uuid: 'uuid2',
+          name: 'foo2',
+          modificationDate: '1',
+        }, {
+          uuid: 'uuid3',
+          name: 'foo',
+          modificationDate: '3',
+          metaData: JSON.stringify({
+            title: 'foouuid3'
+          })
+        }, {
+          uuid: 'uuid4',
+          name: 'foo',
+          modificationDate: '2',
+        }, {
+          uuid: 'uuid5',
+          name: 'foo',
+          modificationDate: '1',
+        }
+      ]),
+      server = this.server;
+
+    this.server.respondWith("GET", search_url, [200, {
+      "Content-Type": "application/json"
+    }, search_result]);
+
+    stop();
+    expect(7);
+
+    this.jio.get('foo')
+      .then(function (result) {
+        deepEqual(result, {
+          title: 'foouuid3'
+        }, "Check document");
+        equal(server.requests.length, 1);
+        equal(server.requests[0].method, "GET");
+        equal(server.requests[0].url, search_url);
+        equal(server.requests[0].requestBody, undefined);
+        equal(server.requests[0].withCredentials, true);
+        deepEqual(server.requests[0].requestHeaders, {
+          "Accept": "application/json"
+        });
+      })
+      .fail(function (error) {
+        ok(false, error);
+      })
+      .always(function () {
+        start();
+      });
+  });
+
+  /////////////////////////////////////////////////////////////////
+  // LinshareStorage.put
+  /////////////////////////////////////////////////////////////////
+  module("LinshareStorage.put", {
+    setup: function () {
+
+      this.server = sinon.fakeServer.create();
+      this.server.autoRespond = true;
+      this.server.autoRespondAfter = 5;
+
+      this.jio = jIO.createJIO({
+        type: "linshare",
+        url: domain
+      });
+
+      this.spy = sinon.spy(FormData.prototype, "append");
+    },
+    teardown: function () {
+      this.server.restore();
+      delete this.server;
+      this.spy.restore();
+      delete this.spy;
+    }
+  });
+
+  test("create a document", function () {
+    var search_url = domain + "/linshare/webservice/rest/user/v2/documents/",
+      search_result = JSON.stringify([
+        {
+          uuid: 'uuid1',
+          name: 'foo1',
+          modificationDate: '2'
+        }, {
+          uuid: 'uuid2',
+          name: 'foo2',
+          modificationDate: '1'
+        }
+      ]),
+      server = this.server,
+      context = this;
+
+    this.server.respondWith("GET", search_url, [200, {
+      "Content-Type": "application/json"
+    }, search_result]);
+
+    this.server.respondWith("POST", search_url, [200, {
+      "Content-Type": "application/json"
+    }, JSON.stringify({})]);
+
+    stop();
+    expect(24);
+
+    this.jio.put('foo', {foo: 'bar'})
+      .then(function (result) {
+        deepEqual(result, 'foo', "Check document");
+        equal(server.requests.length, 2);
+        equal(server.requests[0].method, "GET");
+        equal(server.requests[0].url, search_url);
+        equal(server.requests[0].requestBody, undefined);
+        equal(server.requests[0].withCredentials, true);
+        deepEqual(server.requests[0].requestHeaders, {
+          "Accept": "application/json"
+        });
+
+        equal(server.requests[1].method, "POST");
+        equal(server.requests[1].url, search_url);
+
+        ok(server.requests[1].requestBody instanceof FormData);
+        equal(context.spy.callCount, 5, "FormData.append count");
+
+        equal(context.spy.firstCall.args[0], "file", "First append call");
+        ok(context.spy.firstCall.args[1] instanceof Blob, "First append call");
+        equal(context.spy.firstCall.args[2], "foo", "First append call");
+
+        equal(context.spy.secondCall.args[0], "filesize",
+              "Second append call");
+        equal(context.spy.secondCall.args[1], 0, "Second append call");
+
+        equal(context.spy.thirdCall.args[0], "filename",
+              "Third append call");
+        equal(context.spy.thirdCall.args[1], "foo", "Third append call");
+
+        equal(context.spy.getCall(3).args[0], "description",
+              "Fourth append call");
+        equal(context.spy.getCall(3).args[1], "", "Fourth append call");
+
+        equal(context.spy.getCall(4).args[0], "metadata",
+              "Fourth append call");
+        equal(context.spy.getCall(4).args[1], JSON.stringify({foo: 'bar'}),
+              "Fourth append call");
+
+        equal(server.requests[1].withCredentials, true);
+        deepEqual(server.requests[1].requestHeaders, {
+          "Accept": "application/json",
+          "Content-Type": "text/plain;charset=utf-8"
+        });
+
+      })
+      .fail(function (error) {
+        ok(false, error);
+      })
+      .always(function () {
+        start();
+      });
+  });
+
+  test("update a document", function () {
+    var search_url = domain + "/linshare/webservice/rest/user/v2/documents/",
+      put_url = domain + "/linshare/webservice/rest/user/v2/documents/uuid3",
+      search_result = JSON.stringify([
+        {
+          uuid: 'uuid1',
+          name: 'foo1',
+          modificationDate: '2'
+        }, {
+          uuid: 'uuid2',
+          name: 'foo2',
+          modificationDate: '1'
+        }, {
+          uuid: 'uuid4',
+          name: 'foo',
+          modificationDate: '2',
+        }, {
+          uuid: 'uuid5',
+          name: 'foo',
+          modificationDate: '1',
+        }, {
+          uuid: 'uuid3',
+          name: 'foo',
+          modificationDate: '3',
+          metaData: JSON.stringify({
+            title: 'foouuid3'
+          })
+        }
+      ]),
+      server = this.server,
+      context = this;
+
+    this.server.respondWith("GET", search_url, [200, {
+      "Content-Type": "application/json"
+    }, search_result]);
+
+    this.server.respondWith("PUT", put_url, [200, {
+      "Content-Type": "application/json"
+    }, JSON.stringify({})]);
+
+    stop();
+    expect(13);
+
+    this.jio.put('foo', {foo: 'bar'})
+      .then(function (result) {
+        deepEqual(result, 'foo', "Check document");
+        equal(server.requests.length, 2);
+        equal(server.requests[0].method, "GET");
+        equal(server.requests[0].url, search_url);
+        equal(server.requests[0].requestBody, undefined);
+        equal(server.requests[0].withCredentials, true);
+        deepEqual(server.requests[0].requestHeaders, {
+          "Accept": "application/json"
+        });
+
+        equal(server.requests[1].method, "PUT");
+        equal(server.requests[1].url, put_url);
+
+        ok(
+          server.requests[1].requestBody,
+          JSON.stringify({
+            foo: 'bar'
+          })
+        );
+        equal(context.spy.callCount, 0, "FormData.append count");
+
+        equal(server.requests[1].withCredentials, true);
+        deepEqual(server.requests[1].requestHeaders, {
+          "Accept": "application/json",
+          "Content-Type": "application/json;charset=utf-8"
+        });
+
+      })
+      .fail(function (error) {
+        ok(false, error);
+      })
+      .always(function () {
+        start();
+      });
+  });
+
+  /////////////////////////////////////////////////////////////////
+  // LinshareStorage.remove
+  /////////////////////////////////////////////////////////////////
+  module("LinshareStorage.remove", {
+    setup: function () {
+
+      this.server = sinon.fakeServer.create();
+      this.server.autoRespond = true;
+      this.server.autoRespondAfter = 5;
+
+      this.jio = jIO.createJIO({
+        type: "linshare",
+        url: domain
+      });
+    },
+    teardown: function () {
+      this.server.restore();
+      delete this.server;
+    }
+  });
+
+  test("non existing document", function () {
+    var search_url = domain + "/linshare/webservice/rest/user/v2/documents/",
+      search_result = JSON.stringify([
+        {
+          uuid: 'uuid1',
+          name: 'foo1',
+          modificationDate: '2'
+        }, {
+          uuid: 'uuid2',
+          name: 'foo2',
+          modificationDate: '1'
+        }
+      ]),
+      server = this.server;
+
+    this.server.respondWith("GET", search_url, [200, {
+      "Content-Type": "application/json"
+    }, search_result]);
+
+    stop();
+    expect(7);
+
+    this.jio.remove('foo')
+      .then(function (result) {
+        deepEqual(result, 'foo', "Check document");
+        equal(server.requests.length, 1);
+        equal(server.requests[0].method, "GET");
+        equal(server.requests[0].url, search_url);
+        equal(server.requests[0].requestBody, undefined);
+        equal(server.requests[0].withCredentials, true);
+        deepEqual(server.requests[0].requestHeaders, {
+          "Accept": "application/json"
+        });
+      })
+      .fail(function (error) {
+        ok(false, error);
+      })
+      .always(function () {
+        start();
+      });
+  });
+
+  test("remove a document", function () {
+    var search_url = domain + "/linshare/webservice/rest/user/v2/documents/",
+      remove_url_1 =
+        domain + "/linshare/webservice/rest/user/v2/documents/uuid3",
+      remove_url_2 =
+        domain + "/linshare/webservice/rest/user/v2/documents/uuid4",
+      remove_url_3 =
+        domain + "/linshare/webservice/rest/user/v2/documents/uuid5",
+      search_result = JSON.stringify([
+        {
+          uuid: 'uuid1',
+          name: 'foo1',
+          modificationDate: '2'
+        }, {
+          uuid: 'uuid2',
+          name: 'foo2',
+          modificationDate: '1'
+        }, {
+          uuid: 'uuid4',
+          name: 'foo',
+          modificationDate: '2',
+        }, {
+          uuid: 'uuid5',
+          name: 'foo',
+          modificationDate: '1',
+        }, {
+          uuid: 'uuid3',
+          name: 'foo',
+          modificationDate: '3',
+          metaData: JSON.stringify({
+            title: 'foouuid3'
+          })
+        }
+      ]),
+      server = this.server;
+
+    this.server.respondWith("GET", search_url, [200, {
+      "Content-Type": "application/json"
+    }, search_result]);
+
+    this.server.respondWith("DELETE", remove_url_1, [200, {
+      "Content-Type": "application/json"
+    }, JSON.stringify({})]);
+
+    this.server.respondWith("DELETE", remove_url_2, [200, {
+      "Content-Type": "application/json"
+    }, JSON.stringify({})]);
+
+    this.server.respondWith("DELETE", remove_url_3, [200, {
+      "Content-Type": "application/json"
+    }, JSON.stringify({})]);
+
+    stop();
+    expect(22);
+
+    this.jio.remove('foo')
+      .then(function (result) {
+        deepEqual(result, 'foo', "Check document");
+        equal(server.requests.length, 4);
+
+        equal(server.requests[0].method, "GET");
+        equal(server.requests[0].url, search_url);
+        equal(server.requests[0].requestBody, undefined);
+        equal(server.requests[0].withCredentials, true);
+        deepEqual(server.requests[0].requestHeaders, {
+          "Accept": "application/json"
+        });
+
+        equal(server.requests[1].method, "DELETE");
+        equal(server.requests[1].url, remove_url_1);
+        equal(server.requests[1].requestBody, undefined);
+        equal(server.requests[1].withCredentials, true);
+        deepEqual(server.requests[1].requestHeaders, {
+          "Accept": "application/json",
+          "Content-Type": "text/plain;charset=utf-8"
+        });
+
+        equal(server.requests[2].method, "DELETE");
+        equal(server.requests[2].url, remove_url_2);
+        equal(server.requests[2].requestBody, undefined);
+        equal(server.requests[2].withCredentials, true);
+        deepEqual(server.requests[2].requestHeaders, {
+          "Accept": "application/json",
+          "Content-Type": "text/plain;charset=utf-8"
+        });
+
+        equal(server.requests[3].method, "DELETE");
+        equal(server.requests[3].url, remove_url_3);
+        equal(server.requests[3].requestBody, undefined);
+        equal(server.requests[3].withCredentials, true);
+        deepEqual(server.requests[3].requestHeaders, {
+          "Accept": "application/json",
+          "Content-Type": "text/plain;charset=utf-8"
+        });
+
+      })
+      .fail(function (error) {
+        ok(false, error);
+      })
+      .always(function () {
+        start();
+      });
+  });
+
+  /////////////////////////////////////////////////////////////////
+  // LinshareStorage.allAttachments
+  /////////////////////////////////////////////////////////////////
+  module("LinshareStorage.allAttachments", {
+    setup: function () {
+
+      this.server = sinon.fakeServer.create();
+      this.server.autoRespond = true;
+      this.server.autoRespondAfter = 5;
+
+      this.jio = jIO.createJIO({
+        type: "linshare",
+        url: domain
+      });
+    },
+    teardown: function () {
+      this.server.restore();
+      delete this.server;
+    }
+  });
+
+  test("non existing document", function () {
+    var search_url = domain + "/linshare/webservice/rest/user/v2/documents/",
+      search_result = JSON.stringify([
+        {
+          uuid: 'uuid1',
+          name: 'foo1',
+          modificationDate: '2'
+        }, {
+          uuid: 'uuid2',
+          name: 'foo2',
+          modificationDate: '1'
+        }
+      ]),
+      server = this.server;
+
+    this.server.respondWith("GET", search_url, [200, {
+      "Content-Type": "application/json"
+    }, search_result]);
+
+    stop();
+    expect(9);
+
+    this.jio.allAttachments('foo')
+      .fail(function (error) {
+        ok(error instanceof jIO.util.jIOError);
+        equal(error.message, "Can't find document with id : foo");
+        equal(error.status_code, 404);
+
+        equal(server.requests.length, 1);
+        equal(server.requests[0].method, "GET");
+        equal(server.requests[0].url, search_url);
+        equal(server.requests[0].requestBody, undefined);
+        equal(server.requests[0].withCredentials, true);
+        deepEqual(server.requests[0].requestHeaders, {
+          "Accept": "application/json"
+        });
+      })
+      .fail(function (error) {
+        ok(false, error);
+      })
+      .always(function () {
+        start();
+      });
+  });
+
+  test("existing document", function () {
+    var search_url = domain + "/linshare/webservice/rest/user/v2/documents/",
+      search_result = JSON.stringify([
+        {
+          uuid: 'uuid1',
+          name: 'foo1',
+          modificationDate: '2'
+        }, {
+          uuid: 'uuid2',
+          name: 'foo2',
+          modificationDate: '1'
+        }, {
+          uuid: 'uuid4',
+          name: 'foo',
+          modificationDate: '2',
+        }, {
+          uuid: 'uuid5',
+          name: 'foo',
+          modificationDate: '1',
+        }, {
+          uuid: 'uuid3',
+          name: 'foo',
+          modificationDate: '3',
+          metaData: JSON.stringify({
+            title: 'foouuid3'
+          })
+        }
+      ]),
+      server = this.server;
+
+    this.server.respondWith("GET", search_url, [200, {
+      "Content-Type": "application/json"
+    }, search_result]);
+
+    stop();
+    expect(7);
+
+    this.jio.allAttachments('foo')
+      .then(function (result) {
+        deepEqual(result, {enclosure: {}}, "Check document");
+        equal(server.requests.length, 1);
+
+        equal(server.requests[0].method, "GET");
+        equal(server.requests[0].url, search_url);
+        equal(server.requests[0].requestBody, undefined);
+        equal(server.requests[0].withCredentials, true);
+        deepEqual(server.requests[0].requestHeaders, {
+          "Accept": "application/json"
+        });
+      })
+      .fail(function (error) {
+        ok(false, error);
+      })
+      .always(function () {
+        start();
+      });
+  });
+
+  /////////////////////////////////////////////////////////////////
+  // LinshareStorage.putAttachment
+  /////////////////////////////////////////////////////////////////
+  module("LinshareStorage.putAttachment", {
+    setup: function () {
+
+      this.server = sinon.fakeServer.create();
+      this.server.autoRespond = true;
+      this.server.autoRespondAfter = 5;
+
+      this.jio = jIO.createJIO({
+        type: "linshare",
+        url: domain
+      });
+
+      this.spy = sinon.spy(FormData.prototype, "append");
+    },
+    teardown: function () {
+      this.server.restore();
+      delete this.server;
+      this.spy.restore();
+      delete this.spy;
+    }
+  });
+
+  test("forbidden attachment", function () {
+    var server = this.server;
+
+    stop();
+    expect(4);
+
+    this.jio.putAttachment('foo', 'bar', new Blob())
+      .fail(function (error) {
+        ok(error instanceof jIO.util.jIOError);
+        equal(error.message, "attachment name bar is forbidden in linshare");
+        equal(error.status_code, 400);
+
+        equal(server.requests.length, 0);
+      })
+      .fail(function (error) {
+        ok(false, error);
+      })
+      .always(function () {
+        start();
+      });
+  });
+
+  test("non existing document", function () {
+    var search_url = domain + "/linshare/webservice/rest/user/v2/documents/",
+      search_result = JSON.stringify([
+        {
+          uuid: 'uuid1',
+          name: 'foo1',
+          modificationDate: '2'
+        }, {
+          uuid: 'uuid2',
+          name: 'foo2',
+          modificationDate: '1'
+        }
+      ]),
+      server = this.server;
+
+    this.server.respondWith("GET", search_url, [200, {
+      "Content-Type": "application/json"
+    }, search_result]);
+
+    stop();
+    expect(9);
+
+    this.jio.putAttachment('foo', 'enclosure', new Blob())
+      .fail(function (error) {
+        ok(error instanceof jIO.util.jIOError);
+        equal(error.message, "Can't find document with id : foo");
+        equal(error.status_code, 404);
+
+        equal(server.requests.length, 1);
+        equal(server.requests[0].method, "GET");
+        equal(server.requests[0].url, search_url);
+        equal(server.requests[0].requestBody, undefined);
+        equal(server.requests[0].withCredentials, true);
+        deepEqual(server.requests[0].requestHeaders, {
+          "Accept": "application/json"
+        });
+      })
+      .fail(function (error) {
+        ok(false, error);
+      })
+      .always(function () {
+        start();
+      });
+  });
+
+  test("update a document", function () {
+    var search_url = domain + "/linshare/webservice/rest/user/v2/documents/",
+      search_result = JSON.stringify([
+        {
+          uuid: 'uuid1',
+          name: 'foo1',
+          modificationDate: '2'
+        }, {
+          uuid: 'uuid2',
+          name: 'foo2',
+          modificationDate: '1'
+        }, {
+          uuid: 'uuid4',
+          name: 'foo',
+          modificationDate: '2',
+        }, {
+          uuid: 'uuid5',
+          name: 'foo',
+          modificationDate: '1',
+        }, {
+          uuid: 'uuid3',
+          name: 'foo',
+          modificationDate: '3',
+          metaData: JSON.stringify({
+            title: 'foouuid3'
+          })
+        }
+      ]),
+      server = this.server,
+      context = this,
+      blob = new Blob(['barfoo']);
+
+    this.server.respondWith("GET", search_url, [200, {
+      "Content-Type": "application/json"
+    }, search_result]);
+
+    this.server.respondWith("POST", search_url, [200, {
+      "Content-Type": "application/json"
+    }, JSON.stringify({})]);
+
+    stop();
+    expect(24);
+
+    this.jio.putAttachment('foo', 'enclosure', blob)
+      .then(function (result) {
+        deepEqual(result, {}, "Check document");
+        equal(server.requests.length, 2);
+        equal(server.requests[0].method, "GET");
+        equal(server.requests[0].url, search_url);
+        equal(server.requests[0].requestBody, undefined);
+        equal(server.requests[0].withCredentials, true);
+        deepEqual(server.requests[0].requestHeaders, {
+          "Accept": "application/json"
+        });
+
+        equal(server.requests[1].method, "POST");
+        equal(server.requests[1].url, search_url);
+
+        ok(server.requests[1].requestBody instanceof FormData);
+        equal(context.spy.callCount, 5, "FormData.append count");
+
+        equal(context.spy.firstCall.args[0], "file", "First append call");
+        equal(context.spy.firstCall.args[1], blob, "First append call");
+        equal(context.spy.firstCall.args[2], "foo", "First append call");
+
+        equal(context.spy.secondCall.args[0], "filesize",
+              "Second append call");
+        equal(context.spy.secondCall.args[1], blob.size, "Second append call");
+
+        equal(context.spy.thirdCall.args[0], "filename",
+              "Third append call");
+        equal(context.spy.thirdCall.args[1], "foo", "Third append call");
+
+        equal(context.spy.getCall(3).args[0], "description",
+              "Fourth append call");
+        equal(context.spy.getCall(3).args[1], "foouuid3", "Fourth append call");
+
+        equal(context.spy.getCall(4).args[0], "metadata",
+              "Fourth append call");
+        equal(context.spy.getCall(4).args[1],
+              JSON.stringify({title: 'foouuid3'}),
+              "Fourth append call");
+
+        equal(server.requests[1].withCredentials, true);
+        deepEqual(server.requests[1].requestHeaders, {
+          "Accept": "application/json",
+          "Content-Type": "text/plain;charset=utf-8"
+        });
+
+      })
+      .fail(function (error) {
+        ok(false, error);
+      })
+      .always(function () {
+        start();
+      });
+  });
+
+  /////////////////////////////////////////////////////////////////
+  // LinshareStorage.getAttachment
+  /////////////////////////////////////////////////////////////////
+  module("LinshareStorage.getAttachment", {
+    setup: function () {
+
+      this.server = sinon.fakeServer.create();
+      this.server.autoRespond = true;
+      this.server.autoRespondAfter = 5;
+
+      this.jio = jIO.createJIO({
+        type: "linshare",
+        url: domain
+      });
+    },
+    teardown: function () {
+      this.server.restore();
+      delete this.server;
+    }
+  });
+
+  test("forbidden attachment", function () {
+    var server = this.server;
+
+    stop();
+    expect(4);
+
+    this.jio.getAttachment('foo', 'bar')
+      .fail(function (error) {
+        ok(error instanceof jIO.util.jIOError);
+        equal(error.message, "attachment name bar is forbidden in linshare");
+        equal(error.status_code, 400);
+
+        equal(server.requests.length, 0);
+      })
+      .fail(function (error) {
+        ok(false, error);
+      })
+      .always(function () {
+        start();
+      });
+  });
+
+  test("non existing document", function () {
+    var search_url = domain + "/linshare/webservice/rest/user/v2/documents/",
+      search_result = JSON.stringify([
+        {
+          uuid: 'uuid1',
+          name: 'foo1',
+          modificationDate: '2'
+        }, {
+          uuid: 'uuid2',
+          name: 'foo2',
+          modificationDate: '1'
+        }
+      ]),
+      server = this.server;
+
+    this.server.respondWith("GET", search_url, [200, {
+      "Content-Type": "application/json"
+    }, search_result]);
+
+    stop();
+    expect(9);
+
+    this.jio.getAttachment('foo', 'enclosure')
+      .fail(function (error) {
+        ok(error instanceof jIO.util.jIOError);
+        equal(error.message, "Can't find document with id : foo");
+        equal(error.status_code, 404);
+
+        equal(server.requests.length, 1);
+        equal(server.requests[0].method, "GET");
+        equal(server.requests[0].url, search_url);
+        equal(server.requests[0].requestBody, undefined);
+        equal(server.requests[0].withCredentials, true);
+        deepEqual(server.requests[0].requestHeaders, {
+          "Accept": "application/json"
+        });
+      })
+      .fail(function (error) {
+        ok(false, error);
+      })
+      .always(function () {
+        start();
+      });
+  });
+
+  test("retrieve a document", function () {
+    var search_url = domain + "/linshare/webservice/rest/user/v2/documents/",
+      search_result = JSON.stringify([
+        {
+          uuid: 'uuid1',
+          name: 'foo1',
+          modificationDate: '2'
+        }, {
+          uuid: 'uuid2',
+          name: 'foo2',
+          modificationDate: '1'
+        }, {
+          uuid: 'uuid4',
+          name: 'foo',
+          modificationDate: '2',
+        }, {
+          uuid: 'uuid5',
+          name: 'foo',
+          modificationDate: '1',
+        }, {
+          uuid: 'uuid3',
+          name: 'foo',
+          modificationDate: '3',
+          metaData: JSON.stringify({
+            title: 'foouuid3'
+          })
+        }
+      ]),
+      download_url =
+        domain + "/linshare/webservice/rest/user/v2/documents/uuid3/download",
+      server = this.server;
+
+    this.server.respondWith("GET", search_url, [200, {
+      "Content-Type": "application/json"
+    }, search_result]);
+
+    this.server.respondWith("GET", download_url, [200, {
+      "Content-Type": "text/plain"
+    }, "foo\nbaré"]);
+
+    stop();
+    expect(14);
+
+    this.jio.getAttachment('foo', 'enclosure')
+      .then(function (result) {
+        equal(server.requests.length, 2);
+        equal(server.requests[0].method, "GET");
+        equal(server.requests[0].url, search_url);
+        equal(server.requests[0].requestBody, undefined);
+        equal(server.requests[0].withCredentials, true);
+        deepEqual(server.requests[0].requestHeaders, {
+          "Accept": "application/json"
+        });
+
+        equal(server.requests[1].method, "GET");
+        equal(server.requests[1].url, download_url);
+        equal(server.requests[1].requestBody, undefined);
+        equal(server.requests[1].withCredentials, true);
+        deepEqual(server.requests[1].requestHeaders, {});
+
+        ok(result instanceof Blob, "Data is Blob");
+        deepEqual(result.type, "text/plain", "Check mimetype");
+        return jIO.util.readBlobAsText(result);
+      })
+      .then(function (result) {
+        var expected = "foo\nbaré";
+        equal(result.target.result, expected, "Attachment correctly fetched");
+      })
+      .fail(function (error) {
+        ok(false, error);
+      })
+      .always(function () {
+        start();
+      });
+  });
+
+}(jIO, QUnit, Blob, sinon, FormData));

test/tests.html

@@ -55,6 +55,7 @@ See https://www.nexedi.com/licensing for rationale and options.
   <script src="jio.storage/davstorage.tests.js"></script>
   <script src="jio.storage/drivetojiomapping.tests.js"></script>
   <script src="jio.storage/unionstorage.tests.js"></script>
+  <script src="jio.storage/linsharestorage.tests.js"></script>
   <script src="jio.storage/erp5storage.tests.js"></script>
   <script src="jio.storage/indexeddbstorage.tests.js"></script>
   <script src="jio.storage/uuidstorage.tests.js"></script>