Add memorystorage in the build.

Add tests for memorystorage.
Drop copy/paste code in jio.post. Should be added in a standalone storage if needed.

Gruntfile.js

@@ -171,6 +171,7 @@ module.exports = function (grunt) {
 
           'src/jio.js',
 
+          'src/jio.storage/memorystorage.js',
           'src/jio.storage/localstorage.js',
           'src/jio.storage/davstorage.js',
           'src/jio.storage/unionstorage.js',

src/jio.storage/memorystorage.js

@@ -4,8 +4,8 @@
  * http://www.gnu.org/licenses/lgpl.html
  */
 
-/*jslint nomen: true, maxlen: 200*/
-/*global jIO, window, Blob, Uint8Array, RSVP, console */
+/*jslint nomen: true*/
+/*global jIO*/
 
 /**
  * JIO Memory Storage. Type = 'memory'.
@@ -34,19 +34,6 @@
   }
 
 
-  MemoryStorage.prototype.post = function (metadata) {
-    var doc_id = metadata._id;
-    if (doc_id === undefined) {
-      doc_id = jIO.util.generateUuid();
-    }
-    if (this._database.hasOwnProperty(doc_id)) {
-      // the document already exists
-      throw new jIO.util.jIOError("Cannot create a new document", 409);
-    }
-    metadata._id = doc_id;
-    return this.put(metadata);
-  };
-
   MemoryStorage.prototype.put = function (metadata) {
     if (!this._database.hasOwnProperty(metadata._id)) {
       this._database[metadata._id] = {
@@ -58,24 +45,35 @@
   };
 
   MemoryStorage.prototype.get = function (param) {
-    if (!this._database.hasOwnProperty(param._id)) {
-      throw new jIO.util.jIOError("Cannot find document", 404);
+    try {
+      return JSON.parse(this._database[param._id].doc);
+    } catch (error) {
+      if (error instanceof TypeError) {
+        throw new jIO.util.jIOError(
+          "Cannot find document: " + param._id,
+          404
+        );
       }
-    var doc = JSON.parse(this._database[param._id].doc),
-      key,
-      found = false,
-      attachments = {};
-
-    for (key in this._database[param._id].attachments) {
-      if (this._database[param._id].attachments.hasOwnProperty(key)) {
-        found = true;
-        attachments[key] = {};
+      throw error;
     }
-    }
-    if (found) {
-      doc._attachments = attachments;
-    }
-    return doc;
+
+    // XXX NotImplemented: list all attachments
+
+//     var doc = JSON.parse(this._database[param._id].doc),
+//       key,
+//       found = false,
+//       attachments = {};
+// 
+//     for (key in this._database[param._id].attachments) {
+//       if (this._database[param._id].attachments.hasOwnProperty(key)) {
+//         found = true;
+//         attachments[key] = {};
+//       }
+//     }
+//     if (found) {
+//       doc._attachments = attachments;
+//     }
+//     return doc;
   };
 
   MemoryStorage.prototype.remove = function (param) {
@@ -84,24 +82,47 @@
   };
 
   MemoryStorage.prototype.getAttachment = function (param) {
-    if (!((this._database.hasOwnProperty(param._id)) &&
-          (this._database[param._id].attachments.hasOwnProperty(param._attachments)))) {
-      throw new jIO.util.jIOError("Cannot find attachment", 404);
-    }
+    try {
       return this._database[param._id].attachments[param._attachment];
+    } catch (error) {
+      if (error instanceof TypeError) {
+        throw new jIO.util.jIOError(
+          "Cannot find attachment: " + param._id + " , " + param._attachment,
+          404
+        );
+      }
+      throw error;
+    }
   };
 
   MemoryStorage.prototype.putAttachment = function (param) {
-    this._database[param._id].attachments[param._attachment] =
-      param._blob;
+    var attachment_dict;
+    try {
+      attachment_dict = this._database[param._id].attachments;
+    } catch (error) {
+      if (error instanceof TypeError) {
+        throw new jIO.util.jIOError("Cannot find document: " + param._id, 404);
+      }
+      throw error;
+    }
+    attachment_dict[param._attachment] = param._blob;
   };
 
   MemoryStorage.prototype.removeAttachment = function (param) {
+    try {
       delete this._database[param._id].attachments[param._attachment];
+    } catch (error) {
+      if (error instanceof TypeError) {
+        throw new jIO.util.jIOError(
+          "Cannot find document: " + param._id,
+          404
+        );
+      }
+      throw error;
+    }
   };
 
 
-
   MemoryStorage.prototype.hasCapacity = function (name) {
     return (name === "list");
   };

test/jio.storage/memorystorage.tests.js

+/*jslint nomen: true */
+/*global Blob*/
+(function (jIO, QUnit, Blob) {
+  "use strict";
+  var test = QUnit.test,
+    stop = QUnit.stop,
+    start = QUnit.start,
+    ok = QUnit.ok,
+    expect = QUnit.expect,
+    deepEqual = QUnit.deepEqual,
+    equal = QUnit.equal,
+    module = QUnit.module;
+
+  /////////////////////////////////////////////////////////////////
+  // memoryStorage constructor
+  /////////////////////////////////////////////////////////////////
+  module("memoryStorage.constructor");
+
+  test("Storage has a memory database", function () {
+    var jio = jIO.createJIO({
+      "type": "memory"
+    });
+
+    equal(jio.__type, "memory");
+    deepEqual(jio.__storage._database, {});
+  });
+
+  test("Storage's memory database is not shared", function () {
+    var jio = jIO.createJIO({
+      "type": "memory"
+    }),
+      jio2 = jIO.createJIO({
+        "type": "memory"
+      });
+
+    ok(jio.__storage._database !== jio2.__storage._database,
+       "Database is not shared");
+  });
+
+  /////////////////////////////////////////////////////////////////
+  // memoryStorage.put
+  /////////////////////////////////////////////////////////////////
+  module("memoryStorage.put", {
+    setup: function () {
+      this.jio = jIO.createJIO({
+        "type": "memory"
+      });
+    }
+  });
+  test("put non empty document", function () {
+    expect(2);
+    stop();
+
+    var test = this;
+
+    this.jio.put({"_id": "put1", "title": "myPut1"})
+      .then(function (uuid) {
+        equal(uuid, "put1");
+        deepEqual(test.jio.__storage._database.put1, {
+          attachments: {},
+          doc: JSON.stringify({
+            "_id": "put1",
+            "title": "myPut1"
+          })
+        });
+      })
+      .fail(function (error) {
+        ok(false, error);
+      })
+      .always(function () {
+        start();
+      });
+  });
+
+  test("put when document already exists", function () {
+    var id = "put1",
+      test = this;
+    this.jio.__storage._database[id] = {
+      "foo": "bar",
+      "attachments": {"foo": "bar"},
+      "doc": "foobar"
+    };
+    expect(2);
+    stop();
+
+    this.jio.put({"_id": id, "title": "myPut2"})
+      .then(function (uuid) {
+        equal(uuid, "put1");
+        deepEqual(test.jio.__storage._database.put1, {
+          "foo": "bar",
+          "attachments": {"foo": "bar"},
+          doc: JSON.stringify({
+            "_id": "put1",
+            "title": "myPut2"
+          })
+        });
+      })
+      .fail(function (error) {
+        ok(false, error);
+      })
+      .always(function () {
+        start();
+      });
+  });
+
+  /////////////////////////////////////////////////////////////////
+  // memoryStorage.get
+  /////////////////////////////////////////////////////////////////
+  module("memoryStorage.get", {
+    setup: function () {
+      this.jio = jIO.createJIO({
+        "type": "memory"
+      });
+    }
+  });
+
+  test("get inexistent document", function () {
+    stop();
+    expect(3);
+
+    this.jio.get({"_id": "inexistent"})
+      .fail(function (error) {
+        ok(error instanceof jIO.util.jIOError, error);
+        equal(error.message, "Cannot find document: inexistent");
+        equal(error.status_code, 404);
+      })
+      .fail(function (error) {
+        ok(false, error);
+      })
+      .always(function () {
+        start();
+      });
+  });
+
+  test("get document", function () {
+    var id = "post1";
+    this.jio.__storage._database[id] = {
+      "doc": JSON.stringify({title: "myPost1"})
+    };
+    stop();
+    expect(1);
+
+    this.jio.get({"_id": id})
+      .then(function (result) {
+        deepEqual(result, {
+          "_id": id,
+          "title": "myPost1"
+        }, "Check document");
+      })
+      .fail(function (error) {
+        ok(false, error);
+      })
+      .always(function () {
+        start();
+      });
+  });
+
+//   test("get document with attachment", function () {
+//     var id = "putattmt1";
+// 
+//     this.jio.__storage._database[id] = {
+//       "doc": JSON.stringify({}),
+//       "attachments": {
+//         putattmt2: undefined
+//       }
+//     };
+// 
+//     stop();
+//     expect(1);
+// 
+//     this.jio.get({"_id": id})
+//       .then(function (result) {
+//         deepEqual(result, {
+//           "_id": id,
+//           "_attachment": {},
+//           "title": "myPost1"
+//         }, "Check document");
+//       })
+//       .fail(function (error) {
+//         ok(false, error);
+//       })
+//       .always(function () {
+//         start();
+//       });
+//   });
+
+  /////////////////////////////////////////////////////////////////
+  // memoryStorage.remove
+  /////////////////////////////////////////////////////////////////
+  module("memoryStorage.remove", {
+    setup: function () {
+      this.jio = jIO.createJIO({
+        "type": "memory"
+      });
+    }
+  });
+
+  test("remove document", function () {
+    var id = "foo";
+
+    this.jio.__storage._database[id] = {
+      "doc": JSON.stringify({title: "myPost1"})
+    };
+
+    stop();
+    expect(1);
+
+    this.jio.remove({"_id": "foo"})
+      .then(function (result) {
+        equal(result, "foo");
+      })
+      .fail(function (error) {
+        ok(false, error);
+      })
+      .always(function () {
+        start();
+      });
+  });
+
+  /////////////////////////////////////////////////////////////////
+  // memoryStorage.getAttachment
+  /////////////////////////////////////////////////////////////////
+  module("memoryStorage.getAttachment", {
+    setup: function () {
+      this.jio = jIO.createJIO({
+        "type": "memory"
+      });
+    }
+  });
+  test("get attachment from inexistent document", function () {
+    stop();
+    expect(3);
+
+    this.jio.getAttachment({
+      "_id": "inexistent",
+      "_attachment": "a"
+    })
+      .fail(function (error) {
+        ok(error instanceof jIO.util.jIOError);
+        equal(error.message, "Cannot find attachment: inexistent , a");
+        equal(error.status_code, 404);
+      })
+      .fail(function (error) {
+        ok(false, error);
+      })
+      .always(function () {
+        start();
+      });
+  });
+
+  test("get inexistent attachment from document", function () {
+    var id = "b";
+    stop();
+    expect(3);
+
+    this.jio.__storage._database[id] = {
+      "doc": JSON.stringify({})
+    };
+
+    this.jio.getAttachment({
+      "_id": id,
+      "_attachment": "inexistent"
+    })
+      .fail(function (error) {
+        ok(error instanceof jIO.util.jIOError);
+        equal(error.message, "Cannot find attachment: b , inexistent");
+        equal(error.status_code, 404);
+      })
+      .fail(function (error) {
+        ok(false, error);
+      })
+      .always(function () {
+        start();
+      });
+  });
+
+  test("get attachment from document", function () {
+    var id = "putattmt1",
+      attachment = "putattmt2",
+      blob = new Blob(["test"], {"type": "x-application/foo"});
+    stop();
+    expect(2);
+
+    this.jio.__storage._database[id] = {
+      "doc": JSON.stringify({}),
+      "attachments": {
+        "putattmt2": blob
+      }
+    };
+
+    this.jio.getAttachment({
+      "_id": id,
+      "_attachment": attachment
+    })
+      .then(function (result) {
+        ok(result.data instanceof Blob, "Data is Blob");
+        equal(result.data, blob);
+      })
+      .fail(function (error) {
+        ok(false, error);
+      })
+      .always(function () {
+        start();
+      });
+  });
+
+
+  /////////////////////////////////////////////////////////////////
+  // memoryStorage.putAttachment
+  /////////////////////////////////////////////////////////////////
+  module("memoryStorage.putAttachment", {
+    setup: function () {
+      this.jio = jIO.createJIO({
+        "type": "memory"
+      });
+    }
+  });
+  test("put an attachment to an inexistent document", function () {
+    stop();
+    expect(3);
+
+    this.jio.putAttachment({
+      "_id": "inexistent",
+      "_attachment": "putattmt2",
+      "_data": ""
+    })
+      .fail(function (error) {
+        ok(error instanceof jIO.util.jIOError, error);
+        equal(error.message, "Cannot find document: inexistent");
+        equal(error.status_code, 404);
+      })
+      .fail(function (error) {
+        ok(false, error);
+      })
+      .always(function () {
+        start();
+      });
+  });
+
+  test("put an attachment to a document", function () {
+    var id = "putattmt1",
+      blob = new Blob(["test"], {"type": "x-application/foo"}),
+      jio = this.jio;
+
+    jio.__storage._database[id] = {
+      "doc": JSON.stringify({"foo": "bar"}),
+      "attachments": {}
+    };
+
+    stop();
+    expect(1);
+
+    jio.putAttachment({
+      "_id": id,
+      "_attachment": "putattmt2",
+      "_blob": blob
+    })
+      .then(function () {
+        equal(jio.__storage._database[id].attachments.putattmt2, blob);
+      })
+      .fail(function (error) {
+        ok(false, error);
+      })
+
+      .always(function () {
+        start();
+      });
+  });
+
+  /////////////////////////////////////////////////////////////////
+  // memoryStorage.removeAttachment
+  /////////////////////////////////////////////////////////////////
+  module("memoryStorage.removeAttachment", {
+    setup: function () {
+      this.jio = jIO.createJIO({
+        "type": "memory"
+      });
+    }
+  });
+  test("remove an attachment to an inexistent document", function () {
+    stop();
+    expect(3);
+
+    this.jio.removeAttachment({
+      "_id": "inexistent",
+      "_attachment": "removeattmt2"
+    })
+      .fail(function (error) {
+        ok(error instanceof jIO.util.jIOError, error);
+        equal(error.message, "Cannot find document: inexistent");
+        equal(error.status_code, 404);
+      })
+      .fail(function (error) {
+        ok(false, error);
+      })
+      .always(function () {
+        start();
+      });
+  });
+
+  test("remove an attachment to a document", function () {
+    var id = "removeattmt1",
+      jio = this.jio;
+
+    jio.__storage._database[id] = {
+      "doc": JSON.stringify({"foo": "bar"}),
+      "attachments": {"removeattmt2": "bar"}
+    };
+
+    stop();
+    expect(1);
+
+    jio.removeAttachment({
+      "_id": id,
+      "_attachment": "removeattmt2"
+    })
+      .then(function () {
+        deepEqual(jio.__storage._database[id].attachments, {});
+      })
+      .fail(function (error) {
+        ok(false, error);
+      })
+
+      .always(function () {
+        start();
+      });
+  });
+
+  /////////////////////////////////////////////////////////////////
+  // memoryStorage.hasCapacity
+  /////////////////////////////////////////////////////////////////
+  module("memoryStorage.hasCapacity", {
+    setup: function () {
+      this.jio = jIO.createJIO({
+        "type": "memory"
+      });
+    }
+  });
+  test("can list documents", function () {
+    ok(this.jio.hasCapacity("list"));
+  });
+
+  /////////////////////////////////////////////////////////////////
+  // memoryStorage.buildQuery
+  /////////////////////////////////////////////////////////////////
+  module("memoryStorage.buildQuery", {
+    setup: function () {
+      this.jio = jIO.createJIO({
+        "type": "memory"
+      });
+    }
+  });
+
+  test("list documents", function () {
+    this.jio.__storage._database.foo2 = "bar2";
+    this.jio.__storage._database.foo1 = "bar1";
+
+    stop();
+    expect(1);
+
+    this.jio.allDocs()
+      .then(function (result) {
+        deepEqual(result, {
+          "data": {
+            "rows": [
+              {
+                "id": "foo2",
+                "value": {}
+              },
+              {
+                "id": "foo1",
+                "value": {}
+              }
+            ],
+            "total_rows": 2
+          }
+        });
+      })
+      .fail(function (error) {
+        ok(false, error);
+      })
+
+      .always(function () {
+        start();
+      });
+  });
+
+}(jIO, QUnit, Blob));