js: revert changes to class read/write restriction

--

* undoes 94ee0988d4eaac27785de6efb7c19ca9976e1e9c and
  e16a87e83910ebb6bfdc4148369165f121f0997e.
  I do not fully understand why my approach was bad, but I am not in
  a position to argue. This revert was requested to me after a review,
  and I'm doing it in the assumption that more experienced people know
  better than me.
* unittests: Also changed some outdated tests that stopped working
  since 754e799d35fd62d7a979452f44342934659908c7 (as GPGME_Key is not
  exported, one cannot check for instanceof in the tests anymore)

1 files changed, 155 insertions, 166 deletions

diff --git a/lang/js/src/Message.js b/lang/js/src/Message.js
index e2c07344..2134fe99 100644
--- a/lang/js/src/Message.js
+++ b/lang/js/src/Message.js
@@ -36,7 +36,7 @@ export function createMessage(operation){
         return gpgme_error('PARAM_WRONG');
     }
     if (permittedOperations.hasOwnProperty(operation)){
-        return Object.freeze(new GPGME_Message(operation));
+        return new GPGME_Message(operation);
     } else {
         return gpgme_error('MSG_WRONG_OP');
     }
@@ -52,199 +52,188 @@ export function createMessage(operation){
 export class GPGME_Message {
 
     constructor(operation){
-        let _msg = {
+        this._msg = {
             op: operation,
             chunksize: 1023* 1024
         };
-        let expected = null;
+        this._expected = null;
+    }
 
-        this.getOperation = function(){
-            return _msg.op;
-        };
+    get operation(){
+        return this._msg.op;
+    }
 
-        this.setExpect = function(value){
-            if (value === 'base64'){
-                expected = value;
-            }
-        };
-        this.getExpect = function(){
-            return expected;
-        };
+    set expected (value){
+        if (value === 'base64'){
+            this._expected = value;
+        }
+    }
 
-        /**
-         * The maximum size of responses from gpgme in bytes. As of July 2018,
-         * most browsers will only accept answers up to 1 MB of size.
-         * Everything above that threshold will not pass through
-         * nativeMessaging; answers that are larger need to be sent in parts.
-         * The lower limit is set to 10 KB. Messages smaller than the threshold
-         * will not encounter problems, larger messages will be received in
-         * chunks. If the value is not explicitly specified, 1023 KB is used.
-         */
-        this.setChunksize = function (value){
-            if (
-                Number.isInteger(value) &&
-                value > 10 * 1024 &&
-                value <= 1024 * 1024
-            ){
-                _msg.chunksize = value;
-            }
-        };
+    get expected() {
+        return this._expected;
+    }
+    /**
+     * The maximum size of responses from gpgme in bytes. As of July 2018,
+     * most browsers will only accept answers up to 1 MB of size.
+     * Everything above that threshold will not pass through
+     * nativeMessaging; answers that are larger need to be sent in parts.
+     * The lower limit is set to 10 KB. Messages smaller than the threshold
+     * will not encounter problems, larger messages will be received in
+     * chunks. If the value is not explicitly specified, 1023 KB is used.
+     */
+    set chunksize(value){
+        if (
+            Number.isInteger(value) &&
+            value > 10 * 1024 &&
+            value <= 1024 * 1024
+        ){
+            this._msg.chunksize = value;
+        }
+    }
 
-        this.getMsg = function(){
-            return _msg;
-        };
+    get chunksize(){
+        return this._msg.chunksize;
+    }
 
-        this.getChunksize= function() {
-            return _msg.chunksize;
-        };
+    /**
+     * Returns the prepared message with parameters and completeness checked
+     * @returns {Object|null} Object to be posted to gnupg, or null if
+     * incomplete
+     */
+    get message() {
+        if (this.isComplete() === true){
+            return this._msg;
+        } else {
+            return null;
+        }
+    }
 
-        /**
-         * Sets a parameter for the message. It validates with
-         *      {@link permittedOperations}
-         * @param {String} param Parameter to set
-         * @param {any} value Value to set
-         * @returns {Boolean} If the parameter was set successfully
-         */
-        this.setParameter = function ( param,value ){
-            if (!param || typeof(param) !== 'string'){
+    /**
+     * Sets a parameter for the message. It validates with
+     *      {@link permittedOperations}
+     * @param {String} param Parameter to set
+     * @param {any} value Value to set
+     * @returns {Boolean} If the parameter was set successfully
+     */
+    setParameter ( param,value ){
+        if (!param || typeof(param) !== 'string'){
+            return gpgme_error('PARAM_WRONG');
+        }
+        let po = permittedOperations[this._msg.op];
+        if (!po){
+            return gpgme_error('MSG_WRONG_OP');
+        }
+        let poparam = null;
+        if (po.required.hasOwnProperty(param)){
+            poparam = po.required[param];
+        } else if (po.optional.hasOwnProperty(param)){
+            poparam = po.optional[param];
+        } else {
+            return gpgme_error('PARAM_WRONG');
+        }
+        // check incoming value for correctness
+        let checktype = function(val){
+            switch(typeof(val)){
+            case 'string':
+                if (poparam.allowed.indexOf(typeof(val)) >= 0
+                        && val.length > 0) {
+                    return true;
+                }
                 return gpgme_error('PARAM_WRONG');
-            }
-            let po = permittedOperations[_msg.op];
-            if (!po){
-                return gpgme_error('MSG_WRONG_OP');
-            }
-            let poparam = null;
-            if (po.required.hasOwnProperty(param)){
-                poparam = po.required[param];
-            } else if (po.optional.hasOwnProperty(param)){
-                poparam = po.optional[param];
-            } else {
+            case 'number':
+                if (
+                    poparam.allowed.indexOf('number') >= 0
+                        && isNaN(value) === false){
+                    return true;
+                }
                 return gpgme_error('PARAM_WRONG');
-            }
-            // check incoming value for correctness
-            let checktype = function(val){
-                switch(typeof(val)){
-                case 'string':
-                    if (poparam.allowed.indexOf(typeof(val)) >= 0
-                            && val.length > 0) {
-                        return true;
+
+            case 'boolean':
+                if (poparam.allowed.indexOf('boolean') >= 0){
+                    return true;
+                }
+                return gpgme_error('PARAM_WRONG');
+            case 'object':
+                if (Array.isArray(val)){
+                    if (poparam.array_allowed !== true){
+                        return gpgme_error('PARAM_WRONG');
                     }
-                    return gpgme_error('PARAM_WRONG');
-                case 'number':
-                    if (
-                        poparam.allowed.indexOf('number') >= 0
-                            && isNaN(value) === false){
+                    for (let i=0; i < val.length; i++){
+                        let res = checktype(val[i]);
+                        if (res !== true){
+                            return res;
+                        }
+                    }
+                    if (val.length > 0) {
                         return true;
                     }
-                    return gpgme_error('PARAM_WRONG');
-
-                case 'boolean':
-                    if (poparam.allowed.indexOf('boolean') >= 0){
+                } else if (val instanceof Uint8Array){
+                    if (poparam.allowed.indexOf('Uint8Array') >= 0){
                         return true;
                     }
                     return gpgme_error('PARAM_WRONG');
-                case 'object':
-                    if (Array.isArray(val)){
-                        if (poparam.array_allowed !== true){
-                            return gpgme_error('PARAM_WRONG');
-                        }
-                        for (let i=0; i < val.length; i++){
-                            let res = checktype(val[i]);
-                            if (res !== true){
-                                return res;
-                            }
-                        }
-                        if (val.length > 0) {
-                            return true;
-                        }
-                    } else if (val instanceof Uint8Array){
-                        if (poparam.allowed.indexOf('Uint8Array') >= 0){
-                            return true;
-                        }
-                        return gpgme_error('PARAM_WRONG');
-                    } else {
-                        return gpgme_error('PARAM_WRONG');
-                    }
-                    break;
-                default:
-                    return gpgme_error('PARAM_WRONG');
-                }
-            };
-            let typechecked = checktype(value);
-            if (typechecked !== true){
-                return typechecked;
-            }
-            if (poparam.hasOwnProperty('allowed_data')){
-                if (poparam.allowed_data.indexOf(value) < 0){
+                } else {
                     return gpgme_error('PARAM_WRONG');
                 }
+                break;
+            default:
+                return gpgme_error('PARAM_WRONG');
             }
-            _msg[param] = value;
-            return true;
         };
-
-
-
-        /**
-         * Check if the message has the minimum requirements to be sent, that is
-         * all 'required' parameters according to {@link permittedOperations}.
-         * @returns {Boolean} true if message is complete.
-         */
-        this.isComplete = function(){
-            if (!_msg.op){
-                return false;
-            }
-            let reqParams = Object.keys(
-                permittedOperations[_msg.op].required);
-            let msg_params = Object.keys(_msg);
-            for (let i=0; i < reqParams.length; i++){
-                if (msg_params.indexOf(reqParams[i]) < 0){
-                    return false;
-                }
+        let typechecked = checktype(value);
+        if (typechecked !== true){
+            return typechecked;
+        }
+        if (poparam.hasOwnProperty('allowed_data')){
+            if (poparam.allowed_data.indexOf(value) < 0){
+                return gpgme_error('PARAM_WRONG');
             }
-            return true;
-        };
-        /**
-         * Sends the Message via nativeMessaging and resolves with the answer.
-         * @returns {Promise<Object|GPGME_Error>}
-         * @async
-         */
-        this.post = function(){
-            let me = this;
-            return new Promise(function(resolve, reject) {
-                if (me.isComplete() === true) {
-
-                    let conn  = Object.freeze(new Connection);
-                    conn.post(me).then(function(response) {
-                        resolve(response);
-                    }, function(reason) {
-                        reject(reason);
-                    });
-                }
-                else {
-                    reject(gpgme_error('MSG_INCOMPLETE'));
-                }
-            });
-        };
+        }
+        this._msg[param] = value;
+        return true;
     }
 
+
     /**
-     * Returns the prepared message with parameters and completeness checked
-     * @returns {Object|null} Object to be posted to gnupg, or null if
-     * incomplete
+     * Check if the message has the minimum requirements to be sent, that is
+     * all 'required' parameters according to {@link permittedOperations}.
+     * @returns {Boolean} true if message is complete.
      */
-    get message(){
-        if (this.isComplete() === true){
-            return this.getMsg();
+    isComplete(){
+        if (!this._msg.op){
+            return false;
         }
-        else {
-            return null;
+        let reqParams = Object.keys(
+            permittedOperations[this._msg.op].required);
+        let msg_params = Object.keys(this._msg);
+        for (let i=0; i < reqParams.length; i++){
+            if (msg_params.indexOf(reqParams[i]) < 0){
+                return false;
+            }
         }
+        return true;
     }
-    get operation(){
-        return this.getOperation();
-    }
-    get chunksize(){
-        return this.getChunksize();
+    /**
+     * Sends the Message via nativeMessaging and resolves with the answer.
+     * @returns {Promise<Object|GPGME_Error>}
+     * @async
+     */
+    post (){
+        let me = this;
+        return new Promise(function(resolve, reject) {
+            if (me.isComplete() === true) {
+
+                let conn  = new Connection;
+                conn.post(me).then(function(response) {
+                    resolve(response);
+                }, function(reason) {
+                    reject(reason);
+                });
+            }
+            else {
+                reject(gpgme_error('MSG_INCOMPLETE'));
+            }
+        });
     }
+
 }