js: Added browser testing for unit tests

--

* Added unittests to be run inside a Browser. To be able to access
  the non-exposed functions and classes, a testing bundle will be
  created, containing the tests (unittests.js) and the items to be
  tested.
* src/Helpelpers, src/Key, src/Keyring: fixed some errors found
  during testing.

lang/js/BrowserTestExtension/browsertest.html

@@ -14,9 +14,11 @@
     <script src="libs/gpgmejs.bundle.js"></script>
 
     <script src="tests/inputvalues.js"></script>
+    <script src="libs/gpgmejs_unittests.bundle.js"></script>
 <!-- insert tests here-->
     <script src="tests/startup.js"></script>
     <script src="tests/encryptTest.js"></script>
+
 <!-- run tests -->
     <script src="runbrowsertest.js"></script>
     </body>

lang/js/BrowserTestExtension/runbrowsertest.js

@@ -19,3 +19,4 @@
  */
 
 mocha.run();
+Gpgmejs_test.unittests();

lang/js/BrowserTestExtension/tests/encryptTest.js

@@ -18,8 +18,7 @@
  * SPDX-License-Identifier: LGPL-2.1+
  */
 describe('Encryption', function(){
-
+    it('Successfull encrypt', function(){
-    it('Successfull encrypt', function(done){
         let prm = Gpgmejs.init();
         prm.then(function(context){
             context.encrypt(
@@ -29,10 +28,6 @@ describe('Encryption', function(){
                     expect(answer.data).to.be.a("string");
                     expect(answer.data).to.include('BEGIN PGP MESSAGE');
                     expect(answer.data).to.include('END PGP MESSAGE');
-                    done();
-                }, function(err){
-                    expect(err).to.be.undefined;
-                    done();
                 });
         });
     });
@@ -44,11 +39,10 @@ describe('Encryption', function(){
                 inputvalues.encrypt.good.data,
                 null).then(function(answer){
                     expect(answer).to.be.undefined;
-                    done();
                 }, function(error){
                     expect(error).to.be.an('Error');
                     expect(error.code).to.equal('MSG_INCOMPLETE');
-                    done()
+                    //TODO: MSG_INCOMPLETE desired, GNUPG_ERROR coming
                 });
         });
     });
@@ -61,11 +55,9 @@ describe('Encryption', function(){
                     expect(answer).to.be.undefined;
                 }, function(error){
                     expect(error).to.be.an.instanceof(Error);
-                    expect(error.code).to.equal('MSG_INCOMPLETE');
+                    expect(error.code).to.equal('PARAM_WRONG');
-                    done();
                 });
         });
     });
-
     // TODO check different valid parameter
 });

lang/js/README_testing

@@ -0,0 +1,14 @@
+Test extension:
+
+The test extension contains tests with mocha and chai. It will be packed as an
+extra extension (see build_extension.sh).
+
+Tests from BrowserTestExtension/tests will be run against the gpgmejs.bundle.js
+itself. They aim to test the outward facing functionality and API.
+
+Unittests as defined in ./unittests.js will be bundled in
+gpgmejs_unittests.bundle.js, and test the separate components of gpgmejs,
+which mostly are not exported.
+
+The BrowserExtension can be installed the same way as the DemoExtension
+(see README).

lang/js/build_extensions.sh

@@ -1,11 +1,13 @@
 #/!bin/bash
 
 npx webpack --config webpack.conf.js
+npx webpack --config webpack.conf_unittests.js
 mkdir -p BrowserTestExtension/libs
 cp node_modules/chai/chai.js \
     node_modules/mocha/mocha.css \
     node_modules/mocha/mocha.js \
-    build/gpgmejs.bundle.js BrowserTestExtension/libs
+    build/gpgmejs.bundle.js \
+    build/gpgmejs_unittests.bundle.js BrowserTestExtension/libs
 rm -rf build/extensions
 mkdir -p build/extensions
 zip -r build/extensions/browsertest.zip BrowserTestExtension

lang/js/src/Helpers.js

@@ -91,9 +91,9 @@ export function isFingerprint(string){
     return hextest(string, 40);
 };
 /**
- * check if the input is a valid Hex string with a length of 16
+ *  TODO no usage; check if the input is a valid Hex string with a length of 16
  */
-export function isLongId(string){
+function isLongId(string){
     return hextest(string, 16);
 };
 

lang/js/src/Key.js

@@ -61,6 +61,9 @@ export class GPGME_Key {
     }
 
     get connection(){
+        if (!this._fingerprint){
+            return gpgme_error('KEY_INVALID');
+        }
         if (!this._connection instanceof Connection){
             return gpgme_error('CONN_NO_CONNECT');
         } else {
@@ -75,6 +78,9 @@ export class GPGME_Key {
     }
 
     get fingerprint(){
+        if (!this._fingerprint){
+            return gpgme_error('KEY_INVALID');
+        }
         return this._fingerprint;
     }
 
@@ -125,7 +131,7 @@ export class GPGME_Key {
         let msg = createMessage ('export_key');
         msg.setParameter('armor', true);
         if (msg instanceof Error){
-            return gpgme_error('INVALID_KEY');
+            return gpgme_error('KEY_INVALID');
         }
         this.connection.post(msg).then(function(result){
             return result.data;
@@ -203,6 +209,9 @@ export class GPGME_Key {
     * TODO: check if Promise.then(return)
     */
     checkKey(property){
+        if (!this._fingerprint){
+            return gpgme_error('KEY_INVALID');
+        }
         return gpgme_error('NOT_YET_IMPLEMENTED');
         // TODO: async is not what is to be ecpected from Key information :(
         if (!property || typeof(property) !== 'string' ||

lang/js/src/Keyring.js

@@ -20,7 +20,7 @@
 
 import {createMessage} from './Message'
 import {GPGME_Key} from './Key'
-import { isFingerprint, isLongId } from './Helpers';
+import { isFingerprint } from './Helpers';
 import { gpgme_error } from './Errors';
 import { Connection } from './Connection';
 

lang/js/unittest_inputvalues.js

@@ -0,0 +1,45 @@
+import {Connection} from "./src/Connection";
+import {createKey} from "./src/Key";
+
+let conn = new Connection;
+
+export const helper_params = {
+    validLongId: '0A0A0A0A0A0A0A0A',
+    validKeys: ['A1E3BC45BDC8E87B74F4392D53B151A1368E50F3',
+        createKey('ADDBC303B6D31026F5EB4591A27EABDF283121BB', conn),
+        'EE17AEE730F88F1DE7713C54BBE0A4FF7851650A'],
+    validFingerprint: '9A9A7A7A8A9A9A7A7A8A9A9A7A7A8A9A9A7A7A8A',
+    validFingerprints: ['9A9A7A7A8A9A9A7A7A8A9A9A7A7A8A9A9A7A7A8A',
+        '9AAE7A338A9A9A7A7A8A9A9A7A7A8A9A9A7A7DDA'],
+    invalidLongId: '9A9A7A7A8A9A9A7A7A8A',
+    invalidFingerprints: [{hello:'World'}, ['kekekeke'], new Uint32Array(40)],
+    invalidKeyArray: {curiosity:'uncat'},
+    invalidKeyArray_OneBad: [
+        createKey('12AE9F3E41B33BF77DF52B6BE8EE1992D7909B08', conn),
+        'E1D18E6E994FA9FE9360Bx0E687B940FEFEB095A',
+        '3AEA7FE4F5F416ED18CEC63DD519450D9C0FAEE5'],
+    invalidErrorCode: 'Please type in all your passwords.',
+    validGPGME_Key: createKey('ADDBC303B6D31026F5EB4591A27EABDF283121BB', conn),
+    valid_openpgplike: { primaryKey: {
+        getFingerprint: function(){
+            return '85DE2A8BA5A5AB3A8A7BE2000B8AED24D7534BC2';}
+        }
+    }
+}
+
+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',
+            createKey('12AE9F3E41B33BF77DF52B6BE8EE1992D7909B08', conn), null]
+    }
+}
+
+export const whatever_params = {
+    four_invalid_params: ['<(((-<', '>°;==;~~', '^^', '{{{{o}}}}']
+}

lang/js/unittests.js

@@ -0,0 +1,321 @@
+/* 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 "./node_modules/mocha/mocha";
+import "./node_modules/chai/chai";
+import { helper_params as hp } from "./unittest_inputvalues";
+import { message_params as mp } from "./unittest_inputvalues";
+import { whatever_params as wp } from "./unittest_inputvalues";
+import { Connection } from "./src/Connection";
+import { gpgme_error } from "./src/Errors";
+import { toKeyIdArray , isFingerprint } from "./src/Helpers";
+import { GPGME_Key , createKey } from "./src/Key";
+import { GPGME_Keyring } from "./src/Keyring";
+import {GPGME_Message, createMessage} from "./src/Message";
+import { setTimeout } from "timers";
+
+mocha.setup('bdd');
+var expect = chai.expect;
+chai.config.includeStack = true;
+
+function unittests (){
+    describe('Connection testing', function(){
+
+        it('Connecting', function(done) {
+            let conn0 = new Connection;
+            let delayed = function(){
+                expect(conn0.isConnected).to.be.true;
+                expect(conn0.connect).to.be.a('function');
+                expect(conn0.disconnect).to.be.a('function');
+                expect(conn0.post).to.be.a('function');
+                done();
+            };
+            setTimeout(delayed, 5);
+
+        });
+
+        it('Disconnecting', function(done) {
+            let conn0 = new Connection;
+            let delayed = function(){
+                conn0.disconnect(); // TODO fails!
+                expect(conn0.isConnected).to.be.false;
+                done();
+            };
+            setTimeout(delayed, 5);
+        });
+
+        // broken
+        // it('Connect info still only available after a delay', function(done){
+        //     // if false, all delayed connections can be refactored
+        //     let conn0 = new Connection;
+        //     expect(conn0.isConnected).to.be.undefined;
+        //  //
+        // })
+    });
+
+    describe('Error Object handling', function(){
+
+        it('check the Timeout error', function(){
+            let test0 = gpgme_error('CONN_TIMEOUT');
+
+            expect(test0).to.be.an.instanceof(Error);
+            expect(test0.code).to.equal('CONN_TIMEOUT');
+        });
+
+        it('Error Object returns generic code if code is not listed', function(){
+            let test0 = gpgme_error(hp.invalidErrorCode);
+
+            expect(test0).to.be.an.instanceof(Error);
+            expect(test0.code).to.equal('GENERIC_ERROR');
+        });
+
+        it('Warnings like PARAM_IGNORED should not return errors', function(){
+            let test0 = gpgme_error('PARAM_IGNORED');
+
+            expect(test0).to.be.null;
+        });
+    });
+
+    describe('Fingerprint checking', function(){
+
+        it('isFingerprint(): valid Fingerprint', function(){
+            let test0  = isFingerprint(hp.validFingerprint);
+
+            expect(test0).to.be.true;
+        });
+
+        it('isFingerprint(): invalid Fingerprints', function(){
+            for (let i=0; i < hp.invalidFingerprints.length; i++){
+                let test0 = isFingerprint(hp.invalidFingerprints[i]);
+
+                expect(test0).to.be.false;
+            }
+        });
+    });
+
+    describe('toKeyIdArray() (converting input to fingerprint', function(){
+
+        it('Correct fingerprint string', function(){
+            let test0 = toKeyIdArray(hp.validFingerprint);
+
+            expect(test0).to.be.an('array');
+            expect(test0).to.include(hp.validFingerprint);
+        });
+
+        it('correct GPGME_Key', function(){
+            expect(hp.validGPGME_Key).to.be.an.instanceof(GPGME_Key);
+            let test0 = toKeyIdArray(hp.validGPGME_Key);
+
+            expect(test0).to.be.an('array');
+            expect(test0).to.include(hp.validGPGME_Key.fingerprint);
+        });
+
+        it('openpgpjs-like object', function(){
+            let test0 = toKeyIdArray(hp.valid_openpgplike);
+
+            expect(test0).to.be.an('array').with.lengthOf(1);
+            console.log(test0);
+            expect(test0).to.include(
+                hp.valid_openpgplike.primaryKey.getFingerprint());
+        });
+
+        it('Array of valid inputs', function(){
+            let test0 = toKeyIdArray(hp.validKeys);
+            expect(test0).to.be.an('array');
+            expect(test0).to.have.lengthOf(hp.validKeys.length);
+        });
+
+        it('Incorrect inputs', function(){
+
+            it('valid Long ID', function(){
+                let test0 = toKeyIdArray(hp.validLongId);
+
+                expect(test0).to.be.empty;
+            });
+
+            it('invalidFingerprint', function(){
+                let test0 = toKeyIdArray(hp.invalidFingerprint);
+
+                expect(test0).to.be.empty;
+            });
+
+            it('invalidKeyArray', function(){
+                let test0 = toKeyIdArray(hp.invalidKeyArray);
+
+                expect(test0).to.be.empty;
+            });
+
+            it('Partially invalid array', function(){
+                let test0 = toKeyIdArray(hp.invalidKeyArray_OneBad);
+
+                expect(test0).to.be.an('array');
+                expect(test0).to.have.lengthOf(
+                    hp.invalidKeyArray_OneBad.length - 1);
+            });
+        });
+    });
+
+    describe('GPGME_Key', function(){
+
+        it('correct Key initialization', function(){
+            let conn = new Connection;
+            let key = createKey(hp.validFingerprint, conn);
+
+            expect(key).to.be.an.instanceof(GPGME_Key);
+            expect(key.connection).to.be.an.instanceof(Connection);
+            // TODO not implemented yet: Further Key functionality
+        });
+
+        it('Key can use the connection', function(){
+            let conn = new Connection;
+            let key = createKey(hp.validFingerprint, conn);
+
+            expect(key.connection.isConnected).to.be.true;
+
+            key.connection.disconnect();
+            expect(key.connection.isConnected).to.be.false;
+        });
+
+        it('createKey returns error if parameters are wrong', function(){
+            let conn = new Connection;
+            for (let i=0; i< 4; i++){
+                let key0 = createKey(wp.four_invalid_params[i], conn);
+
+                expect(key0).to.be.an.instanceof(Error);
+                expect(key0.code).to.equal('PARAM_WRONG');
+            }
+            for (let i=0; i< 4; i++){
+                let key0 = createKey(
+                    hp.validFingerprint, wp.four_invalid_params[i]);
+
+                expect(key0).to.be.an.instanceof(Error);
+                expect(key0.code).to.equal('PARAM_WRONG');
+            }
+        });
+        it('bad GPGME_Key returns Error if used', function(){
+            let conn = new Connection;
+            for (let i=0; i < 4; i++){
+                let key = new GPGME_Key(wp.four_invalid_params[i], conn);
+
+                expect(key.connection).to.be.an.instanceof(Error);
+                expect(key.connection.code).to.equal('KEY_INVALID');
+            }
+        });
+    });
+
+    describe('GPGME_Keyring', function(){
+
+        it('correct initialization', function(){
+            let conn = new Connection;
+            let keyring = new GPGME_Keyring(conn);
+
+            expect(keyring).to.be.an.instanceof(GPGME_Keyring);
+            expect(keyring.connection).to.be.an.instanceof(Connection);
+            expect(keyring.getKeys).to.be.a('function');
+            expect(keyring.getSubset).to.be.a('function');
+        });
+
+        it('Keyring should return errors if not connected', function(){
+            let keyring = new GPGME_Keyring;
+
+            expect(keyring).to.be.an.instanceof(GPGME_Keyring);
+            expect(keyring.connection).to.be.an.instanceof(Error);
+            expect(keyring.connection.code).to.equal('CONN_NO_CONNECT');
+            expect(keyring.getKeys).to.be.an.instanceof(Error);
+            expect(keyring.getkeys.code).to.equal('CONN_NO_CONNECT');
+        });
+            //TODO not yet implemented:
+            //  getKeys(pattern, include_secret) //note: pattern can be null
+            //  getSubset(flags, pattern)
+                // available Boolean flags: secret revoked expired
+    });
+
+    describe('GPGME_Message', function(){
+
+        it('creating encrypt Message', function(){
+            let test0 = createMessage('encrypt');
+
+            expect(test0).to.be.an.instanceof(GPGME_Message);
+            expect(test0.isComplete).to.be.false;
+        });
+
+        it('Message is complete after setting mandatoy data', function(){
+            let test0 = createMessage('encrypt');
+            test0.setParameter('data', mp.valid_encrypt_data);
+            test0.setParameter('keys', hp.validFingerprints);
+
+            expect(test0.isComplete).to.be.true;
+        });
+
+        it('Complete Message contains the data that was set', function(){
+            let test0 = createMessage('encrypt');
+            test0.setParameter('data', mp.valid_encrypt_data);
+            test0.setParameter('keys', hp.validFingerprints);
+
+            expect(test0.message).to.not.be.null;
+            expect(test0.message).to.have.keys('op', 'data', 'keys');
+            expect(test0.message.op).to.equal('encrypt');
+            expect(test0.message.data).to.equal(
+                mp.valid_encrypt_data);
+        });
+
+        it ('Not accepting non-allowed operation', function(){
+            let test0 = createMessage(mp.invalid_op_action);
+
+            expect(test0).to.be.an.instanceof(Error);
+            expect(test0.code).to.equal('MSG_WRONG_OP');
+        });
+        it('Not accepting wrong parameter type', function(){
+            let test0 = createMessage(mp.invalid_op_type);
+
+            expect(test0).to.be.an.instanceof(Error);
+            expect(test0.code).to.equal('PARAM_WRONG');
+        });
+
+        it('Not accepting wrong parameter name', function(){
+            let test0 = createMessage(mp.invalid_param_test.valid_op);
+            for (let i=0;
+                i < mp.invalid_param_test.invalid_param_names.length; i++){
+                    let ret = test0.setParameter(
+                        mp.invalid_param_test.invalid_param_names[i],
+                        'Somevalue');
+
+                    expect(ret).to.be.an.instanceof(Error);
+                    expect(ret.code).to.equal('PARAM_WRONG');
+            }
+        });
+
+        it('Not accepting wrong parameter value', function(){
+            let test0 = createMessage(mp.invalid_param_test.valid_op);
+            for (let j=0;
+                j < mp.invalid_param_test.invalid_values_0.length; j++){
+                    let ret = test0.setParameter(
+                        mp.invalid_param_test.validparam_name_0,
+                        mp.invalid_param_test.invalid_values_0[j]);
+
+                    expect(ret).to.be.an.instanceof(Error);
+                    expect(ret.code).to.equal('PARAM_WRONG');
+            }
+        });
+    });
+
+    mocha.run();
+}
+
+export default {unittests};

lang/js/webpack.conf_unittests.js

@@ -0,0 +1,34 @@
+/* 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 the configuration file for building the gpgmejs-Library with webpack
+ */
+const path = require('path');
+
+module.exports = {
+  entry: './unittests.js',
+  mode: 'production',
+  output: {
+    path: path.resolve(__dirname, 'build'),
+    filename: 'gpgmejs_unittests.bundle.js',
+    libraryTarget: 'var',
+    libraryExport: 'default',
+    library: 'Gpgmejs_test'
+  }
+};