js: make method parameters objects
[gpgme.git] / lang / js / BrowserTestExtension / tests / encryptDecryptTest.js
1 /* gpgme.js - Javascript integration for gpgme
2  * Copyright (C) 2018 Bundesamt für Sicherheit in der Informationstechnik
3  *
4  * This file is part of GPGME.
5  *
6  * GPGME is free software; you can redistribute it and/or modify it
7  * under the terms of the GNU Lesser General Public License as
8  * published by the Free Software Foundation; either version 2.1 of
9  * the License, or (at your option) any later version.
10  *
11  * GPGME is distributed in the hope that it will be useful, but
12  * WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
18  * SPDX-License-Identifier: LGPL-2.1+
19  *
20  * Author(s):
21  *     Maximilian Krambach <mkrambach@intevation.de>
22  */
23
24 /* global describe, it, expect, before, Gpgmejs */
25 /* global inputvalues, encryptedData, bigString, bigBoringString */
26
27 describe('Encryption and Decryption', function (){
28     let context = null;
29     let good_fpr = inputvalues.encrypt.good.fingerprint;
30
31     before(function (done){
32         const prm = Gpgmejs.init();
33         prm.then(function (gpgmejs){
34             context = gpgmejs;
35             done();
36         });
37     });
38
39     it('Successful encrypt and decrypt simple string', function (done) {
40         let data = inputvalues.encrypt.good.data;
41         context.encrypt({ data: data, publicKeys: good_fpr }).then(
42             function (answer) {
43                 expect(answer).to.not.be.empty;
44                 expect(answer.data).to.be.a('string');
45                 expect(answer.data).to.include('BEGIN PGP MESSAGE');
46                 expect(answer.data).to.include('END PGP MESSAGE');
47                 context.decrypt({ data: answer.data }).then(function (result) {
48                     expect(result).to.not.be.empty;
49                     expect(result.data).to.be.a('string');
50                     expect(result.data).to.equal(
51                         inputvalues.encrypt.good.data);
52                     done();
53                 });
54             });
55     });
56
57     it('Decrypt simple non-ascii', function (done) {
58         let data = encryptedData;
59         context.decrypt({ data: data }).then(function (result) {
60             expect(result).to.not.be.empty;
61             expect(result.data).to.be.a('string');
62             expect(result.data).to.equal(
63                 '¡Äußerste µ€ før ñoquis@hóme! Добрый день\n');
64             done();
65         });
66     }).timeout(3000);
67
68     it('Trailing whitespace and different line endings', function (done) {
69         const data = 'Keks. \rKeks \n Keks \r\n';
70         context.encrypt({ data: data, publicKeys: good_fpr }).then(
71             function (answer) {
72                 expect(answer).to.not.be.empty;
73                 expect(answer.data).to.be.a('string');
74                 expect(answer.data).to.include('BEGIN PGP MESSAGE');
75                 expect(answer.data).to.include('END PGP MESSAGE');
76
77                 context.decrypt({ data: answer.data }).then(function (result) {
78                     expect(result).to.not.be.empty;
79                     expect(result.data).to.be.a('string');
80                     expect(result.data).to.equal(data);
81                     done();
82                 });
83             });
84     }).timeout(5000);
85
86     it('Random data, as string', function (done) {
87         let data = bigString(1000);
88         context.encrypt({ data:data, publicKeys: good_fpr }).then(
89             function (answer) {
90                 expect(answer).to.not.be.empty;
91                 expect(answer.data).to.be.a('string');
92                 expect(answer.data).to.include(
93                     'BEGIN PGP MESSAGE');
94                 expect(answer.data).to.include(
95                     'END PGP MESSAGE');
96                 context.decrypt({ data: answer.data }).then(function (result) {
97                     expect(result).to.not.be.empty;
98                     expect(result.data).to.be.a('string');
99                     expect(result.data).to.equal(data);
100                     done();
101                 });
102             });
103     }).timeout(3000);
104
105     it('Data, input as base64', function (done) {
106         let data = inputvalues.encrypt.good.data;
107         let b64data = btoa(data);
108         context.encrypt({ data: b64data, publicKeys: good_fpr, base64: true })
109             .then(function (answer) {
110                 expect(answer).to.not.be.empty;
111                 expect(answer.data).to.be.a('string');
112                 expect(answer.data).to.include(
113                     'BEGIN PGP MESSAGE');
114                 expect(answer.data).to.include(
115                     'END PGP MESSAGE');
116                 context.decrypt({ data: answer.data }).then(function (result) {
117                     expect(result).to.not.be.empty;
118                     expect(result.data).to.be.a('string');
119                     expect(result.data).to.equal(data);
120                     done();
121                 });
122             });
123     }).timeout(3000);
124
125     it('Random data, input as base64', function (done) {
126         let data = bigBoringString(0.001);
127         let b64data = btoa(data);
128         context.encrypt(
129             { data: b64data, publicKeys: good_fpr, base64: true })
130             .then(function (answer) {
131                 expect(answer).to.not.be.empty;
132                 expect(answer.data).to.be.a('string');
133                 expect(answer.data).to.include(
134                     'BEGIN PGP MESSAGE');
135                 expect(answer.data).to.include(
136                     'END PGP MESSAGE');
137                 context.decrypt({ data:answer.data }).then(
138                     function (result) {
139                         expect(result).to.not.be.empty;
140                         expect(result.data).to.be.a('string');
141                         expect(result.data).to.equal(data);
142                         done();
143                     });
144             });
145     }).timeout(3000);
146
147     for (let j = 0; j < inputvalues.encrypt.good.data_nonascii_32.length; j++){
148         it('Roundtrip with >1MB non-ascii input meeting default chunksize (' +
149             (j + 1) + '/'
150             + inputvalues.encrypt.good.data_nonascii_32.length + ')',
151         function (done) {
152             let input = inputvalues.encrypt.good.data_nonascii_32[j];
153             expect(input).to.have.length(32);
154             let data = '';
155             for (let i=0; i < 34 * 1024; i++){
156                 data += input;
157             }
158             context.encrypt({ data: data, publicKeys: good_fpr })
159                 .then(function (answer) {
160                     expect(answer).to.not.be.empty;
161                     expect(answer.data).to.be.a('string');
162                     expect(answer.data).to.include(
163                         'BEGIN PGP MESSAGE');
164                     expect(answer.data).to.include(
165                         'END PGP MESSAGE');
166                     context.decrypt({ data: answer.data })
167                         .then(function (result) {
168                             expect(result).to.not.be.empty;
169                             expect(result.data).to.be.a('string');
170                             expect(result.data).to.equal(data);
171                             done();
172                         });
173                 });
174         }).timeout(5000);
175     }
176 });