SecureSerializer class for conveniant use.

src/nodetk/serializer.js

@@ -9,7 +9,8 @@ var crypto = require('crypto')
   ;
 
 
-exports.dump_str = function(obj) {
+var SERIALIZER = exports;
+SERIALIZER.dump_str = function(obj) {
   /* Returns dump of the given JSON obj as a str.
    * There is no encryption, and it might not be safe.
    * Might throw an error.
@@ -22,7 +23,7 @@ exports.dump_str = function(obj) {
 };
 
 
-exports.load_str = function(str) {
+SERIALIZER.load_str = function(str) {
   /* Returns obj loaded from given string. 
    * Might throw an error.
    *
@@ -46,7 +47,7 @@ var CYPHER = 'aes256';
 var CODE_ENCODING = "hex";
 var DATA_ENCODING = "utf8";
 
-exports.dump_secure_str = function(obj, encrypt_key, validate_key) {
+SERIALIZER.dump_secure_str = function(obj, encrypt_key, validate_key) {
   /* Return str representing the given obj. It is signed and encrypted using the
    * given keys.
    */
@@ -63,7 +64,7 @@ exports.dump_secure_str = function(obj, encrypt_key, validate_key) {
   return digest + nonce_crypt + res;
 };
 
-exports.load_secure_str = function(str, encrypt_key, validate_key) {
+SERIALIZER.load_secure_str = function(str, encrypt_key, validate_key) {
   /* Given a string resulting from dump_secure_str, load corresponding JSON.
    */
   var expected_digest = str.substring(0, 28);
@@ -79,3 +80,19 @@ exports.load_secure_str = function(str, encrypt_key, validate_key) {
   return JSON.parse(data);
 };
 
+
+SERIALIZER.SecureSerializer = function(encrypt_key, validate_key) {
+  /* Class to store encryption/validation keys in a more convenient way. */
+  this.encrypt_key = encrypt_key;
+  this.validate_key = validate_key;
+};
+SERIALIZER.SecureSerializer.prototype = {
+  dump_str: function(obj) {
+    return SERIALIZER.dump_secure_str(obj, this.encrypt_key, this.validate_key);
+  }
+, load_str: function(str) {
+    return SERIALIZER.load_secure_str(str, this.encrypt_key, this.validate_key);
+  }
+};
+
+

src/nodetk/tests/test_serializer.js

@@ -22,20 +22,36 @@ var VALS = [
   ];
 
 
+var dont_call = function() {
+  assert.ok(false, "must no be called");
+};
+
+var to_restore = ['dump_secure_str', 'load_secure_str'];
+var originals = {};
+to_restore.forEach(function(original) {
+  originals[original] = serializer[original];
+});
+exports.module_clode = function() {
+  to_restore.forEach(function(original) {
+    serializer[original] = originals[original];
+  });
+};
+
+
 exports.tests = [
 
 ['dump_str & laod_str', VALS.length * 2, function() {
   VALS.forEach(function(val) {
     var dump = serializer.dump_str(val);
     var original = serializer.load_str(dump);
     assert.deepEqual(original, val);
-    // Algorithm determinist:
+    // Algorithm must be determinist:
     var dump2 = serializer.dump_str(val);
     assert.equal(dump, dump2);
   });
 }],
 
-['dump_secure_str', VALS.length * 2, function() {
+['dump_secure_str load_secure_str', VALS.length * 2, function() {
   var encrypt_key = 'somesecretkey';
   var validate_key = 'anothersecretstring';
   VALS.forEach(function(val) {
@@ -48,5 +64,31 @@ exports.tests = [
   });
 }],
 
+['SecureSerializer.dump_str', 3, function() {
+  var ss = new serializer.SecureSerializer('crypt', 'valid');
+  var expected_obj = {}
+  serializer.load_secure_str = dont_call;
+  serializer.dump_secure_str = function(obj, ck, vk) {
+    assert.equal(obj, expected_obj);
+    assert.equal(ck, 'crypt');
+    assert.equal(vk, 'valid');
+    serializer.dump_secure_str = dont_call;
+  };
+  ss.dump_str(expected_obj)
+}],
+
+['SecureSerializer.load_str', 3, function() {
+  var ss = new serializer.SecureSerializer('crypt', 'valid');
+  var expected_str = "secret"
+  serializer.dump_secure_str = dont_call;
+  serializer.load_secure_str = function(str, ck, vk) {
+    assert.equal(str, expected_str);
+    assert.equal(ck, 'crypt');
+    assert.equal(vk, 'valid');
+    serializer.load_secure_str = dont_call;
+  };
+  ss.load_str(expected_str)
+}],
+
 ];