[git] GPGME - branch, javascript-binding, updated. gpgme-1.11.1-20-gc755287
by Maximilian Krambach
cvs at cvs.gnupg.org
Thu May 3 18:05:57 CEST 2018
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "GnuPG Made Easy".
The branch, javascript-binding has been updated
via c755287ba845c4cbbf1d50e5aafecb2e687c7ac9 (commit)
from 6f67814eb45725bc7f3736a2638bad0a7470f17a (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
commit c755287ba845c4cbbf1d50e5aafecb2e687c7ac9
Author: Maximilian Krambach <maximilian.krambach at intevation.de>
Date: Thu May 3 18:03:22 2018 +0200
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.
diff --git a/lang/js/BrowserTestExtension/browsertest.html b/lang/js/BrowserTestExtension/browsertest.html
index d2c6396..ce037a1 100644
--- a/lang/js/BrowserTestExtension/browsertest.html
+++ b/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>
diff --git a/lang/js/BrowserTestExtension/runbrowsertest.js b/lang/js/BrowserTestExtension/runbrowsertest.js
index 39bc3fb..308c716 100644
--- a/lang/js/BrowserTestExtension/runbrowsertest.js
+++ b/lang/js/BrowserTestExtension/runbrowsertest.js
@@ -19,3 +19,4 @@
*/
mocha.run();
+Gpgmejs_test.unittests();
diff --git a/lang/js/BrowserTestExtension/tests/encryptTest.js b/lang/js/BrowserTestExtension/tests/encryptTest.js
index e600000..2178efa 100644
--- a/lang/js/BrowserTestExtension/tests/encryptTest.js
+++ b/lang/js/BrowserTestExtension/tests/encryptTest.js
@@ -18,8 +18,7 @@
* SPDX-License-Identifier: LGPL-2.1+
*/
describe('Encryption', function(){
-
- it('Successfull encrypt', function(done){
+ it('Successfull encrypt', function(){
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');
- done();
+ expect(error.code).to.equal('PARAM_WRONG');
});
});
});
-
// TODO check different valid parameter
});
diff --git a/lang/js/README_testing b/lang/js/README_testing
new file mode 100644
index 0000000..b61ca1a
--- /dev/null
+++ b/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).
\ No newline at end of file
diff --git a/lang/js/build_extensions.sh b/lang/js/build_extensions.sh
index b99a362..91d5479 100755
--- a/lang/js/build_extensions.sh
+++ b/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
diff --git a/lang/js/src/Helpers.js b/lang/js/src/Helpers.js
index 9a69f85..ea056ff 100644
--- a/lang/js/src/Helpers.js
+++ b/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);
};
diff --git a/lang/js/src/Key.js b/lang/js/src/Key.js
index 1e0d319..6d3cf17 100644
--- a/lang/js/src/Key.js
+++ b/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' ||
diff --git a/lang/js/src/Keyring.js b/lang/js/src/Keyring.js
index 2cf87c2..4596035 100644
--- a/lang/js/src/Keyring.js
+++ b/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';
diff --git a/lang/js/unittest_inputvalues.js b/lang/js/unittest_inputvalues.js
new file mode 100644
index 0000000..3450afd
--- /dev/null
+++ b/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}}}}']
+}
diff --git a/lang/js/unittests.js b/lang/js/unittests.js
new file mode 100644
index 0000000..0a1b4b4
--- /dev/null
+++ b/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};
\ No newline at end of file
diff --git a/lang/js/BrowserTestExtension/runbrowsertest.js b/lang/js/webpack.conf_unittests.js
similarity index 69%
copy from lang/js/BrowserTestExtension/runbrowsertest.js
copy to lang/js/webpack.conf_unittests.js
index 39bc3fb..4b903be 100644
--- a/lang/js/BrowserTestExtension/runbrowsertest.js
+++ b/lang/js/webpack.conf_unittests.js
@@ -16,6 +16,19 @@
* 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');
-mocha.run();
+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'
+ }
+};
-----------------------------------------------------------------------
Summary of changes:
lang/js/BrowserTestExtension/browsertest.html | 2 +
lang/js/BrowserTestExtension/runbrowsertest.js | 1 +
lang/js/BrowserTestExtension/tests/encryptTest.js | 14 +-
lang/js/README_testing | 14 +
lang/js/build_extensions.sh | 4 +-
lang/js/src/Helpers.js | 4 +-
lang/js/src/Key.js | 11 +-
lang/js/src/Keyring.js | 2 +-
.../inputvalues.js => unittest_inputvalues.js} | 26 +-
lang/js/unittests.js | 321 +++++++++++++++++++++
.../{webpack.conf.js => webpack.conf_unittests.js} | 7 +-
11 files changed, 376 insertions(+), 30 deletions(-)
create mode 100644 lang/js/README_testing
copy lang/js/{test/inputvalues.js => unittest_inputvalues.js} (60%)
create mode 100644 lang/js/unittests.js
copy lang/js/{webpack.conf.js => webpack.conf_unittests.js} (91%)
hooks/post-receive
--
GnuPG Made Easy
http://git.gnupg.org
More information about the Gnupg-commits
mailing list