diff --git a/lang/js/src/Key.js b/lang/js/src/Key.js
index 30449d63..1e0d3195 100644
--- a/lang/js/src/Key.js
+++ b/lang/js/src/Key.js
@@ -1,205 +1,233 @@
 /* gpgme.js - Javascript integration for gpgme
  * Copyright (C) 2018 Bundesamt für Sicherheit in der Informationstechnik
  *
  * This file is part of GPGME.
  *
  * GPGME is free software; you can redistribute it and/or modify it
  * under the terms of the GNU Lesser General Public License as
  * published by the Free Software Foundation; either version 2.1 of
  * the License, or (at your option) any later version.
  *
  * GPGME is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
  * SPDX-License-Identifier: LGPL-2.1+
  */
 
 /**
  * The key class allows to query the information defined in gpgme Key Objects
  * (see https://www.gnupg.org/documentation/manuals/gpgme/Key-objects.html)
  *
  * This is a stub, as the gpgme-json side is not yet implemented
  *
  */
 
 import { isFingerprint } from './Helpers'
 import { gpgme_error } from './Errors'
 import { createMessage } from './Message';
 import { permittedOperations } from './permittedOperations';
+import { Connection } from './Connection';
+
+
+export function createKey(fingerprint, parent){
+    if (!isFingerprint(fingerprint)){
+        return gpgme_error('KEY_INVALID');
+    }
+    if ( parent instanceof Connection){
+        return new GPGME_Key(fingerprint, parent);
+    } else if ( parent.hasOwnProperty('connection') &&
+        parent.connection instanceof Connection){
+            return new GPGME_Key(fingerprint, parent.connection);
+    }
+}
 
 export class GPGME_Key {
 
-    constructor(fingerprint){
+    constructor(fingerprint, connection){
         this.fingerprint = fingerprint;
+        this.connection = connection;
+    }
+
+    set connection(conn){
+        if (this._connection instanceof Connection) {
+            gpgme_error('CONN_ALREADY_CONNECTED');
+        } else if (conn instanceof Connection ) {
+            this._connection = conn;
+        }
+    }
+
+    get connection(){
+        if (!this._connection instanceof Connection){
+            return gpgme_error('CONN_NO_CONNECT');
+        } else {
+            return this._connection;
+        }
     }
 
     set fingerprint(fpr){
         if (isFingerprint(fpr) === true && !this._fingerprint){
             this._fingerprint = fpr;
         }
     }
 
     get fingerprint(){
         return this._fingerprint;
     }
 
     /**
      * hasSecret returns true if a secret subkey is included in this Key
      */
     get hasSecret(){
-        return checkKey(this._fingerprint, 'secret');
+        return this.checkKey('secret');
     }
 
     get isRevoked(){
-        return checkKey(this._fingerprint, 'revoked');
+        return this.checkKey('revoked');
     }
 
     get isExpired(){
-        return checkKey(this._fingerprint, 'expired');
+        return this.checkKey('expired');
     }
 
     get isDisabled(){
-        return checkKey(this._fingerprint, 'disabled');
+        return this.checkKey('disabled');
     }
 
     get isInvalid(){
-        return checkKey(this._fingerprint, 'invalid');
+        return this.checkKey('invalid');
     }
 
     get canEncrypt(){
-        return checkKey(this._fingerprint, 'can_encrypt');
+        return this.checkKey('can_encrypt');
     }
 
     get canSign(){
-        return checkKey(this._fingerprint, 'can_sign');
+        return this.checkKey('can_sign');
     }
 
     get canCertify(){
-        return checkKey(this._fingerprint, 'can_certify');
+        return this.checkKey('can_certify');
     }
 
     get canAuthenticate(){
-        return checkKey(this._fingerprint, 'can_authenticate');
+        return this.checkKey('can_authenticate');
     }
 
     get isQualified(){
-        return checkKey(this._fingerprint, 'is_qualified');
+        return this.checkKey('is_qualified');
     }
 
     get armored(){
-        let me = this;
-        return new Promise(function(resolve, reject){
-            let conn = new Connection();
-            conn.setFlag('armor', true);
-            conn.post('export',{'fpr': me._fingerprint});
+        let msg = createMessage ('export_key');
+        msg.setParameter('armor', true);
+        if (msg instanceof Error){
+            return gpgme_error('INVALID_KEY');
+        }
+        this.connection.post(msg).then(function(result){
+            return result.data;
         });
         // TODO return value not yet checked. Should result in an armored block
         // in correct encoding
-        // TODO openpgpjs also returns secKey if private = true?
     }
 
     /**
      * TODO returns true if this is the default key used to sign
      */
     get isDefault(){
         throw('NOT_YET_IMPLEMENTED');
     }
 
     /**
      * get the Key's subkeys as GPGME_Key objects
      * @returns {Array<GPGME_Key>}
      */
     get subkeys(){
-        return checkKey(this._fingerprint, 'subkeys').then(function(result){
+        return this.checkKey('subkeys').then(function(result){
             // TBD expecting a list of fingerprints
             if (!Array.isArray(result)){
                 result = [result];
             }
             let resultset = [];
             for (let i=0; i < result.length; i++){
-                let subkey = new GPGME_Key(result[i]);
+                let subkey = new GPGME_Key(result[i], this.connection);
                 if (subkey instanceof GPGME_Key){
                     resultset.push(subkey);
                 }
             }
             return Promise.resolve(resultset);
         }, function(error){
-            //TODO checkKey fails
+            //TODO this.checkKey fails
         });
     }
 
     /**
      * creation time stamp of the key
      * @returns {Date|null} TBD
      */
     get timestamp(){
-        return checkKey(this._fingerprint, 'timestamp');
+        return this.checkKey('timestamp');
         //TODO GPGME: -1 if the timestamp is invalid, and 0 if it is not available.
     }
 
     /**
      * The expiration timestamp of this key TBD
      *  @returns {Date|null} TBD
      */
     get expires(){
-        return checkKey(this._fingerprint, 'expires');
+        return this.checkKey('expires');
         // TODO convert to Date; check for 0
     }
 
     /**
      * getter name TBD
      * @returns {String|Array<String>} The user ids associated with this key
      */
     get userIds(){
-        return checkKey(this._fingerprint, 'uids');
+        return this.checkKey('uids');
     }
 
     /**
      * @returns {String} The public key algorithm supported by this subkey
      */
     get pubkey_algo(){
-        return checkKey(this._fingerprint, 'pubkey_algo');
+        return this.checkKey('pubkey_algo');
     }
-};
 
-/**
- * generic function to query gnupg information on a key.
- * @param {*} fingerprint The identifier of the Keyring
- * @param {*} property The gpgme-json property to check
- *
- */
-function checkKey(fingerprint, property){
-    return Promise.reject(gpgme_error('NOT_YET_IMPLEMENTED'));
-    if (!property || !permittedOperations[keyinfo].hasOwnProperty(property)){
-            return Promise.reject(gpgme_error('PARAM_WRONG'));
-    }
-    return new Promise(function(resolve, reject){
-        if (!isFingerprint(fingerprint)){
-            reject(gpgme_error('KEY_INVALID'));
+    /**
+    * generic function to query gnupg information on a key.
+    * @param {*} property The gpgme-json property to check.
+    * TODO: check if Promise.then(return)
+    */
+    checkKey(property){
+        return gpgme_error('NOT_YET_IMPLEMENTED');
+        // TODO: async is not what is to be ecpected from Key information :(
+        if (!property || typeof(property) !== 'string' ||
+            !permittedOperations['keyinfo'].hasOwnProperty(property)){
+            return gpgme_error('PARAM_WRONG');
         }
         let msg = createMessage ('keyinfo');
         if (msg instanceof Error){
-            reject(gpgme_error('PARAM_WRONG'));
+            return gpgme_error('PARAM_WRONG');
         }
         msg.setParameter('fingerprint', this.fingerprint);
-        return (this.connection.post(msg)).then(function(result, error){
+        this.connection.post(msg).then(function(result, error){
             if (error){
-                reject(gpgme_error('GNUPG_ERROR',error.msg));
+                return gpgme_error('GNUPG_ERROR',error.msg);
             } else if (result.hasOwnProperty(property)){
-                resolve(result[property]);
+                return result[property];
             }
             else if (property == 'secret'){
-                    // TBD property undefined means "not true" in case of secret?
-                    resolve(false);
+                // TBD property undefined means "not true" in case of secret?
+                return false;
             } else {
-                reject(gpgme_error('CONN_UNEXPECTED_ANSWER'));
+                return gpgme_error('CONN_UNEXPECTED_ANSWER');
             }
         }, function(error){
-            //TODO error handling
+            return gpgme_error('GENERIC_ERROR');
         });
-    });
+    }
 };
\ No newline at end of file
diff --git a/lang/js/src/Keyring.js b/lang/js/src/Keyring.js
index d1f4122e..2cf87c24 100644
--- a/lang/js/src/Keyring.js
+++ b/lang/js/src/Keyring.js
@@ -1,161 +1,162 @@
 /* gpgme.js - Javascript integration for gpgme
  * Copyright (C) 2018 Bundesamt für Sicherheit in der Informationstechnik
  *
  * This file is part of GPGME.
  *
  * GPGME is free software; you can redistribute it and/or modify it
  * under the terms of the GNU Lesser General Public License as
  * published by the Free Software Foundation; either version 2.1 of
  * the License, or (at your option) any later version.
  *
  * GPGME is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
  * SPDX-License-Identifier: LGPL-2.1+
  */
 
 import {createMessage} from './Message'
 import {GPGME_Key} from './Key'
 import { isFingerprint, isLongId } from './Helpers';
 import { gpgme_error } from './Errors';
 import { Connection } from './Connection';
 
 export class GPGME_Keyring {
     constructor(connection){
         this.connection = connection;
     }
 
     set connection(connection){
         if (!this._connection && connection instanceof Connection){
             this._connection = connection;
         }
     }
     get connection(){
         if (this._connection instanceof Connection){
             if (this._connection.isConnected){
                 return this._connection;
             }
             return gpgme_error('CONN_DISCONNECTED');
         }
         return gpgme_error('CONN_NO_CONNECT');
     }
 
     /**
      * @param {String} (optional) pattern A pattern to search for, in userIds or KeyIds
      * @param {Boolean} (optional) Include listing of secret keys
      * @returns {Promise.<Array<GPGME_Key>>}
      *
      */
     getKeys(pattern, include_secret){
         let msg = createMessage('listkeys');
         if (msg instanceof Error){
             return Promise.reject(msg);
         }
         if (pattern && typeof(pattern) === 'string'){
             msg.setParameter('pattern', pattern);
         }
         if (include_secret){
             msg.setParameter('with-secret', true);
         }
+        let me = this;
 
         this.connection.post(msg).then(function(result){
             let fpr_list = [];
             let resultset = [];
             if (!Array.isArray(result.keys)){
             //TODO check assumption keys = Array<String fingerprints>
                 fpr_list = [result.keys];
             } else {
                 fpr_list = result.keys;
             }
             for (let i=0; i < fpr_list.length; i++){
-                let newKey = new GPGME_Key(fpr_list[i]);
+                let newKey = new GPGME_Key(fpr_list[i], me._connection);
                 if (newKey instanceof GPGME_Key){
                     resultset.push(newKey);
                 }
             }
             return Promise.resolve(resultset);
         }, function(error){
             //TODO error handling
         });
     }
 
     /**
      * @param {Object} flags subset filter expecting at least one of the
      * filters described below. True will filter on the condition, False will
      * reverse the filter, if not present or undefined, the filter will not be
      * considered. Please note that some combination may not make sense
      * @param {Boolean} flags.secret Only Keys containing a secret part.
      * @param {Boolean} flags.revoked revoked Keys only
      * @param {Boolean} flags.expired Expired Keys only
      * @param {String} (optional) pattern A pattern to search for, in userIds or KeyIds
      * @returns {Promise Array<GPGME_Key>}
      *
      */
     getSubset(flags, pattern){
         if (flags === undefined) {
             throw('ERR_WRONG_PARAM');
         };
         let secretflag = false;
         if (flags.hasOwnProperty(secret) && flags.secret){
             secretflag = true;
         }
         this.getKeys(pattern, secretflag).then(function(queryset){
             let resultset = [];
             for (let i=0; i < queryset.length; i++ ){
                 let conditions = [];
                 let anticonditions = [];
                 if (secretflag === true){
                     conditions.push('hasSecret');
                 } else if (secretflag === false){
                     anticonditions.push('hasSecret');
                 }
                 /**
                 if (flags.defaultKey === true){
                     conditions.push('isDefault');
                 } else if (flags.defaultKey === false){
                     anticonditions.push('isDefault');
                 }
                 */
                 /**
                  * if (flags.valid === true){
                     anticonditions.push('isInvalid');
                 } else if (flags.valid === false){
                     conditions.push('isInvalid');
                 }
                 */
                 if (flags.revoked === true){
                     conditions.push('isRevoked');
                 } else if (flags.revoked === false){
                     anticonditions.push('isRevoked');
                 }
                 if (flags.expired === true){
                     conditions.push('isExpired');
                 } else if (flags.expired === false){
                     anticonditions.push('isExpired');
                 }
                 let decision = undefined;
                 for (let con = 0; con < conditions.length; con ++){
                     if (queryset[i][conditions[con]] !== true){
                         decision = false;
                     }
                 }
                 for (let acon = 0; acon < anticonditions.length; acon ++){
                     if (queryset[i][anticonditions[acon]] === true){
                         decision = false;
                     }
                 }
                 if (decision !== false){
                     resultset.push(queryset[i]);
                 }
             }
             return Promise.resolve(resultset);
         }, function(error){
             //TODO error handling
         });
     }
 
 };
diff --git a/lang/js/src/gpgmejs_openpgpjs.js b/lang/js/src/gpgmejs_openpgpjs.js
index c80d5a86..b233f0fa 100644
--- a/lang/js/src/gpgmejs_openpgpjs.js
+++ b/lang/js/src/gpgmejs_openpgpjs.js
@@ -1,280 +1,290 @@
 /* gpgme.js - Javascript integration for gpgme
  * Copyright (C) 2018 Bundesamt für Sicherheit in der Informationstechnik
  *
  * This file is part of GPGME.
  *
  * GPGME is free software; you can redistribute it and/or modify it
  * under the terms of the GNU Lesser General Public License as
  * published by the Free Software Foundation; either version 2.1 of
  * the License, or (at your option) any later version.
  *
  * GPGME is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
  * SPDX-License-Identifier: LGPL-2.1+
  */
 
 /**
  * This is a compatibility API to be used as openpgpjs syntax.
  * Non-implemented options will throw an error if set (not null or undefined)
  * TODO Some info about differences
  */
 
  import { GpgME } from "./gpgmejs";
  import {GPGME_Keyring}  from "./Keyring"
- import { GPGME_Key } from "./Key";
+ import { GPGME_Key, createKey } from "./Key";
  import { isFingerprint } from "./Helpers"
  import { gpgme_error } from "./Errors"
+import { Connection } from "./Connection";
 
 
  export class GpgME_openpgpmode {
 
     constructor(connection, config = {}){
         this.initGpgME(connection, config);
     }
 
     get Keyring(){
         if (this._keyring){
             return this._keyring;
         }
         return undefined;
     }
 
     initGpgME(connection, config = {}){
         if (connection && typeof(config) ==='object'){
             this._config = config;
-            if (!this._GPGME){
+            if (!this._GpgME){
                 this._GpgME = new GpgME(connection, config);
             }
             if (!this._keyring){
                 this._keyring = new GPGME_Keyring_openpgpmode(connection);
             }
         }
     }
 
     /**
      * Encrypt Message
      * Supported:
      * @param  {String|Uint8Array} data
      * //an openpgp Message also accepted here. TODO: is this wanted?
      * @param  {Key|Array<Key>} publicKeys
      * //Strings of Fingerprints
      * @param  {Boolean} wildcard
      * TODO:
      * @param  {Key|Array<Key>} privateKeys // -> encryptsign
      * @param  {module:enums.compression} compression //TODO accepts integer, if 0 (no compression) it won't compress
      * @param  {Boolean} armor // TODO base64 switch
      * @param  {Boolean} detached // --> encryptsign
      * unsupported:
      * @param  {String|Array<String>} passwords
      * @param  {Object} sessionKey
      * @param  {Signature} signature
      * @param  {Boolean} returnSessionKey
      * @param  {String} filename
      *
      * Can be set, but will be ignored:
      *
      * @returns {Promise<Object>}
      *      {data: ASCII armored message,
      *      signature: detached signature if 'detached' is true
      *      }
     * @async
     * @static
     */
     encrypt({data = '', publicKeys = '', privateKeys, passwords=null,
         sessionKey = null, filename, compression, armor=true, detached=false,
         signature=null, returnSessionKey=null, wildcard=false, date=null}) {
         if (passwords !== null
             || sessionKey !== null
             || signature !== null
             || returnSessionKey !== null
             || date !== null
             ){
             return Promise.reject(GPMGEJS_Error('NOT_IMPLEMENTED'));
         }
         if ( privateKeys
             || compression
             || armor === false
             || detached == true){
                 return Promise.reject(gpgme_error('NOT_YET_IMPLEMENTED'));
         }
         if (filename){
             if (this._config.unconsidered_params === 'warn'){
                 GPMGEJS_Error('PARAM_IGNORED');
             } else if (this._config.unconsidered_params === 'error'){
                 return Promise.reject(GPMGEJS_Error('NOT_IMPLEMENTED'));
             }
         }
         return this._GpgME.encrypt(data, translateKeys(publicKeys), wildcard);
     }
 
     /** Decrypt Message
     * supported openpgpjs parameters:
     * @param {Message|Uint8Array|String} message Message object from openpgpjs
     * Unsupported:
     * @param  {String|Array<String>} passwords
     * @param  {Key|Array<Key>} privateKeys
     * @param  {Object|Array<Object>} sessionKeys
     * Not yet supported, but planned
     * @param  {String} format                    (optional) return data format either as 'utf8' or 'binary'
     * @param  {Signature} signature              (optional) detached signature for verification
     * Ignored values: can be safely set, but have no effect
     * @param  {Date} date
     * @param  {Key|Array<Key>} publicKeys
     *
     * @returns {Promise<Object>}             decrypted and verified message in the form:
     *                                         { data:Uint8Array|String, filename:String, signatures:[{ keyid:String, valid:Boolean }] }
     * @async
     * @static
     */
     decrypt({ message, privateKeys, passwords=null, sessionKeys,
         publicKeys, format='utf8', signature=null, date= null}) {
         if (passwords !== null || sessionKeys || privateKeys){
             return Promise.reject(gpgme_error('NOT_IMPLEMENTED'));
         }
         if ( format !== 'utf8' || signature){
             return Promise.reject(gpgme_error('NOT_YET_IMPLEMENTED'));
         }
         if (date !== null || publicKeys){
             if (this._config.unconsidered_params === 'warn'){
                 GPMGEJS_Error('PARAM_IGNORED');
             } else if (this._config.unconsidered_params === 'reject'){
                 return Promise.reject(GPMGEJS_Error('NOT_IMPLEMENTED'));
             }
         }
         return this._GpgME.decrypt(message);
         // TODO: translate between:
         // openpgp:
         // { data:Uint8Array|String,
         //      filename:String,
         //      signatures:[{ keyid:String, valid:Boolean }] }
         // and gnupg:
         // data:   The decrypted data.  This may be base64 encoded.
         // base64: Boolean indicating whether data is base64 encoded.
         // mime:   A Boolean indicating whether the data is a MIME object.
         // info:   An optional object with extra information.
     }
 }
 
 /**
  * Translation layer offering basic Keyring API to be used in Mailvelope.
  * It may still be changed/expanded/merged with GPGME_Keyring
  */
 class GPGME_Keyring_openpgpmode {
     constructor(connection){
         this._gpgme_keyring = new GPGME_Keyring(connection);
     }
 
     /**
      * Returns a GPGME_Key Object for each Key in the gnupg Keyring. This
      * includes keys openpgpjs considers 'private' (usable for signing), with
      * the difference that Key.armored will NOT contain any secret information.
      * Please also note that a GPGME_Key does not offer full openpgpjs- Key
      * compatibility.
      * @returns {Array<GPGME_Key_openpgpmode>}
      * //TODO: Check if IsDefault is also always hasSecret
      * TODO Check if async is required
      */
     getPublicKeys(){
         return translateKeys(
             this._gpgme_keyring.getKeys(null, true));
     }
 
     /**
      * Returns the Default Key used for crypto operation in gnupg.
      * Please note that the armored property does not contained secret key blocks,
      * despite secret blocks being part of the key itself.
      * @returns {Promise <GPGME_Key>}
      */
     getDefaultKey(){
         this._gpgme_keyring.getSubset({defaultKey: true}).then(function(result){
             if (result.length === 1){
                 return Promise.resolve(
                     translateKeys(result)[0]);
             }
             else {
                 // TODO: Can there be "no default key"?
                 // TODO: Can there be several default keys?
                 return gpgme_error('TODO');
             }
         }, function(error){
             //TODO
         });
     }
 
     /**
      * Deletes a Key
      * @param {Object} Object identifying key
      * @param {String} key.fingerprint - fingerprint of the to be deleted key
      * @param {Boolean} key.secret - indicator if private key should be deleted as well
 
      * @returns {Promise.<Array.<undefined>, Error>} TBD: Not sure what is wanted
      TODO @throws {Error} error.code = ‘KEY_NOT_EXIST’ - there is no key for the given fingerprint
      TODO @throws {Error} error.code = ‘NO_SECRET_KEY’ - secret indicator set, but no secret key exists
      */
     deleteKey(key){
         if (typeof(key) !== "object"){
             return Promise.reject(gpgme_error('PARAM_WRONG'));
         }
         if ( !key.fingerprint || ! isFingerprint(key.fingerprint)){
             return Promise.reject(gpgme_error('PARAM_WRONG'));
         }
-        let key_to_delete = new GPGME_Key(key.fingerprint);
+        let key_to_delete = createKey(key.fingerprint, this._gpgme_keyring_GpgME);
         return key_to_delete.deleteKey(key.secret);
     }
 }
 
 /**
  * TODO error handling.
  * Offers the Key information as the openpgpmode wants
  */
 class GPGME_Key_openpgpmode {
-    constructor(value){
-        this.init = value;
+    constructor(value, connection){
+        this.init(value, connection);
     }
 
-    set init (value){
+    /**
+     * Can be either constructed using an existing GPGME_Key, or a fingerprint
+     * and a connection
+     * @param {String|GPGME_Key} value
+     * @param {Connection} connection
+     */
+    init (value, connection){
         if (!this._GPGME_Key && value instanceof GPGME_Key){
             this._GPGME_Key = value;
-        } else if (!this._GPGME_Key && isFingerprint(value)){
-            this._GPGME_Key = new GPGME_Key(value);
+        } else if (!this._GPGME_Key && isFingerprint(value) &&
+            connection instanceof Connection){
+            this._GPGME_Key = createKey(value, connection);
         }
     }
 
     get fingerprint(){
         return this._GPGME_Key.fingerprint;
     }
 
     get armor(){
         return this._GPGME_Key.armored;
     }
 
     get secret(){
         return this._GPGME_Key.hasSecret;
     }
 
     get default(){
         return this._GPGME_Key.isDefault;
     }
 }
 
 /**
  * creates GPGME_Key_openpgpmode from GPGME_Keys
+ * @param {GPGME_Key|Array<GPGME_Key>} input keys
+ * @returns {Array<GPGME_Key_openpgpmode>}
  */
 function translateKeys(input){
     if (!input){
         return null;
     }
     if (!Array.isArray(input)){
         input = [input];
     }
     let resultset;
     for (let i=0; i< input.length; i++){
         resultset.push(new GPGME_Key_openpgpmode(input[i]));
     }
     return resultset;
 }
\ No newline at end of file
diff --git a/lang/js/src/index.js b/lang/js/src/index.js
index 90fe99e3..fc406c66 100644
--- a/lang/js/src/index.js
+++ b/lang/js/src/index.js
@@ -1,88 +1,91 @@
 /* gpgme.js - Javascript integration for gpgme
  * Copyright (C) 2018 Bundesamt für Sicherheit in der Informationstechnik
  *
  * This file is part of GPGME.
  *
  * GPGME is free software; you can redistribute it and/or modify it
  * under the terms of the GNU Lesser General Public License as
  * published by the Free Software Foundation; either version 2.1 of
  * the License, or (at your option) any later version.
  *
  * GPGME is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
  * SPDX-License-Identifier: LGPL-2.1+
  */
 
 import { GpgME } from "./gpgmejs";
 import { gpgme_error } from "./Errors";
 import { GpgME_openpgpmode } from "./gpgmejs_openpgpjs";
 import { Connection } from "./Connection";
 import { defaultConf, availableConf } from "./Config";
 
 /**
  * Initializes a nativeMessaging Connection and returns a GPGMEjs object
  * @param {Object} config Configuration. See Config.js for available parameters. Still TODO
  */
 function init(config){
     let _conf = parseconfiguration(config);
     if (_conf instanceof Error){
         return Promise.reject(_conf);
     }
     return new Promise(function(resolve, reject){
         let connection = new Connection;
         // TODO: Delayed reaction is ugly. We need to listen to the port's
-        // event listener in isConnected, but this takes some time (<5ms) to
-        // disconnect if there is no successfull connection.
+        // event listener in isConnected, but in some cases this takes some
+        // time (<5ms) to disconnect if there is no successfull connection.
         let delayedreaction = function(){
+            if (connection === undefined) {
+                reject(gpgme_error('CONN_NO_CONNECT'));
+            }
             if (connection.isConnected === true){
                 if (_conf.api_style && _conf.api_style === 'gpgme_openpgpjs'){
                     resolve(new GpgME_openpgpmode(connection, _conf));
                 } else {
                     resolve(new GpgME(connection));
                 }
             } else {
                 reject(gpgme_error('CONN_NO_CONNECT'));
             }
         };
         setTimeout(delayedreaction, 5);
     });
 }
 
 function parseconfiguration(rawconfig = {}){
     if ( typeof(rawconfig) !== 'object'){
         return gpgme_error('PARAM_WRONG');
     };
     let result_config = {};
     let conf_keys = Object.keys(rawconfig);
 
     for (let i=0; i < conf_keys.length; i++){
 
         if (availableConf.hasOwnProperty(conf_keys[i])){
             let value = rawconfig[conf_keys[i]];
             if (availableConf[conf_keys[i]].indexOf(value) < 0){
                 return gpgme_error('PARAM_WRONG');
             } else {
                 result_config[conf_keys[i]] = value;
             }
         }
         else {
             return gpgme_error('PARAM_WRONG');
         }
     }
     let default_keys = Object.keys(defaultConf);
     for (let j=0; j < default_keys.length; j++){
         if (!result_config.hasOwnProperty(default_keys[j])){
             result_config[default_keys[j]] = defaultConf[default_keys[j]];
         }
     }
     return result_config;
 };
 
 export default {
     init: init
 }
\ No newline at end of file
diff --git a/lang/js/test/inputvalues.js b/lang/js/test/inputvalues.js
index f6cd75aa..7752b82f 100644
--- a/lang/js/test/inputvalues.js
+++ b/lang/js/test/inputvalues.js
@@ -1,39 +1,39 @@
-
-import {GPGME_Key} from "../src/Key"
+import { gpgme_error } from "../src/Errors";
 
 export const helper_params = {
     validLongId: '0A0A0A0A0A0A0A0A',
-    validGPGME_Key: new GPGME_Key('ADDBC303B6D31026F5EB4591A27EABDF283121BB'),
-    validKeys: [new GPGME_Key('A1E3BC45BDC8E87B74F4392D53B151A1368E50F3'),
+    validKeys: ['A1E3BC45BDC8E87B74F4392D53B151A1368E50F3',
         'ADDBC303B6D31026F5EB4591A27EABDF283121BB',
-        new GPGME_Key('EE17AEE730F88F1DE7713C54BBE0A4FF7851650A')],
+        'EE17AEE730F88F1DE7713C54BBE0A4FF7851650A'],
     validFingerprint: '9A9A7A7A8A9A9A7A7A8A9A9A7A7A8A9A9A7A7A8A',
     validFingerprints: ['9A9A7A7A8A9A9A7A7A8A9A9A7A7A8A9A9A7A7A8A',
         '9AAE7A338A9A9A7A7A8A9A9A7A7A8A9A9A7A7DDA'],
     invalidLongId: '9A9A7A7A8A9A9A7A7A8A',
     invalidFingerprint: [{hello:'World'}],
     invalidKeyArray: {curiosity:'uncat'},
     invalidKeyArray_OneBad: [
-        new GPGME_Key('12AE9F3E41B33BF77DF52B6BE8EE1992D7909B08'),
+        '12AE9F3E41B33BF77DF52B6BE8EE1992D7909B08',
         'E1D18E6E994FA9FE9360Bx0E687B940FEFEB095A',
         '3AEA7FE4F5F416ED18CEC63DD519450D9C0FAEE5'],
-    invalidErrorCode: 'Please type in all your passwords.'
+    invalidErrorCode: 'Please type in all your passwords.',
 }
 
 export const message_params = {
     invalid_op_action : 'dance',
     invalid_op_type : [234, 34, '<>'],
     valid_encrypt_data: "مرحبا بالعالم",
     invalid_param_test: {
         valid_op: 'encrypt',
         invalid_param_names: [22,'dance', {}],
         validparam_name_0: 'mime',
-        invalid_values_0: [2134, 'All your passwords', new GPGME_Key('12AE9F3E41B33BF77DF52B6BE8EE1992D7909B08'), null]
+        invalid_values_0: [2134, 'All your passwords', gpgme_error('12AE9F3E41B33BF77DF52B6BE8EE1992D7909B08'), null]
     }
 }
-
+export const whatever_params = {
+    four_invalid_params: ['<(((-<', '>°;==;~~', '^^', '{{{{o}}}}']
+}
 
 export default {
     helper_params: helper_params,
     message_params: message_params
 }
\ No newline at end of file